简介
JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。（摘自百度百科）

参考文章：深入理解Java反射
 

代码示例
利用反射机制打印任意一个类

ReflectTest.java

package main;

import java.lang.reflect.*;

import javax.swing.text.html.CSS;

public class ReflectTest {

    private Class thisClass;

    public ReflectTest(Class thisClass) {
        this.thisClass = thisClass;
    }
    
 
    /**
     * 获取类名
     * @return
     */
    private String getName() {
        String className = thisClass.getName();
        
        return className;
    }
 
    /**
     * 获取所有变量
     * @return
     */
    private String getAllField() {
        StringBuilder result = new StringBuilder();
        // 获取所有变量
        Field[] fields = thisClass.getDeclaredFields();
        // 获取公有属性变量的方法：
        // fields = clazz.getFields();
        
        // 循环遍历每个变量
        for (Field field : fields) {
            // 获取变量类型（Class对象)，并getName()转为字符串
            String fieldType = field.getType().getName();
            // 获取变量名称
            String fieldName = field.getName();
            // 获取变量修饰符
            int modifierCode = field.getModifiers();
            String accessType = Modifier.toString(modifierCode);
            result.append("    " + accessType + " " + fieldType + " " + fieldName + ";\n\n");
        }
        return result.toString();
    }
    
 
    /**
     * 获取所有方法
     * @return
     */
    private String getAllMethod() {
        StringBuilder result = new StringBuilder();
        // 获取所有方法
        Method[] methods = thisClass.getDeclaredMethods();
        // 获取公有属性方法的方法：
        // methods = clazz.getMethods();
        
        // 循环遍历每个方法
        for (Method method : methods) {
            // 获取方法返回类型（Class对象)，并getName()转为字符串
            String methodType = method.getReturnType().getName();
            // 获取方法名称
            String methodName = method.getName();
            // 获取方法修饰符
            int modifierCode = method.getModifiers();
            String accessType = Modifier.toString(modifierCode);
            // 获取方法的所有参数
            Parameter parameters[] = method.getParameters();
            result.append("    " + accessType + " " + methodType + " " + methodName + "(");
            // 循环遍历该方法的所有参数
            for (int i = 0; i < parameters.length; i++) {
                Parameter parameter = parameters[i];
                // 获取参数类型，并转为字符串
                String paramType = parameter.getType().toString();
                // 获取参数名称
                String paramName = parameter.getName();
                result.append(paramType + " " + paramName);
                if (i != parameters.length - 1) {
                    result.append(", ");
                }
            }
            result.append(")\n\n");
        }
        return result.toString();
    }
    
    /**
     * 获取所有构造方法
     * @return
     */
    public String getAllConstructors() {
        StringBuilder result = new StringBuilder();
        // 获取所有构造方法
        Constructor[] constructors = thisClass.getDeclaredConstructors();
        // 获取公有属性构造方法的方法
        // constructors = clazz.getConstructors();
        
        // 循环遍历每个构造方法
        for (Constructor constructor : constructors) {
            // 获取构造方法的名称
            String constructorName = constructor.getName();
            // 获取构造方法的修饰符
            int modifierCode = constructor.getModifiers();
            String accessType = Modifier.toString(modifierCode);
            // 获取构造方法的所有参数
            Parameter[] parameters = constructor.getParameters();
            result.append("    " + accessType + " " + constructorName + "(");
            
            //循环遍历每个参数
            for (int i = 0; i < parameters.length; i++) {
                Parameter parameter = parameters[i];
                // 获取参数类型，并转为字符串
                String paramType = parameter.getType().getName();
                // 获取参数名称
                String paramName = parameter.getName();
                result.append(paramType + " " + paramName);
                if (i != parameters.length - 1) {
                    result.append(", ");
                }
            }
            result.append(")\n\n");
        }
        return result.toString();
    }
    
    @Override
    public String toString() {
        String result = new StringBuilder()
                .append(getName() + " {\n\n")
                .append(getAllField())
                .append(getAllConstructors())
                .append(getAllMethod() + "\n}")
                .toString();
        return result;
    }
 
    public static void main(String args[]) {
        Student s1;
        s1 = new Student();
        ReflectTest test = new ReflectTest(s1.getClass());
        System.out.println(test.toString());
    }
}
Student.java

package main;
 
public class Student {
    
    private int id;
    private String name;
    private String sex;
    
    public Student() {
    }
    
    public Student(int id, String name, String sex) {
        
    }
 
    public void setId(int id) {
        this.id = id;
    }
    
    public int getId() {
        return id;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    public String getSex() {
        return sex;
    }
 
}