java反射原理

public class Human {
    public String sex;
    protected String height;
}

import java.io.Serializable;

public class Person extends Human implements Serializable {

    private Integer personId;
    public String personName;
    protected static int personAge;

    public Person(){ 
    }
    private Person(int personId,String personName){
    }
    protected Person(String personName){
    }

    public Integer getPersonId() {
        return personId;
    }

    public void setPersonId(Integer personId) {
        this.personId = personId;
    }

    public String getPersonName() {
        return personName;
    }

    private void setPersonName(String personName) {
        this.personName = personName;
    }

    public int getPersonAge() {
        return personAge;
    }

}

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;

public class ReflectDemo {
    /**
     * 三种获取类的Class对象的方式
     */
    @Test
    public void testCreateClass() throws Exception {
        //通过.class获取
        System.out.println(Person.class);
        //通过Class对象中的classForName()获取
        Class<?> aClass = Class.forName("com.xzy.reflect.Person");
        System.out.println(aClass);
        //通过类的实例获取
        Person person = new Person();
        System.out.println(person.getClass());
    }

    /**
     * 获取一个类中的属性
     */
    @Test
    public void testClassForField(){
        //获取类的Class对象
        Class<Person> clazz = Person.class;
        //获取类中的所有属性
        //getFields()方法获取类中所有public属性,包括父类的共有属性
        Field[] fields = clazz.getFields();
        for (Field field:fields){
            System.out.println(field);
        }

        System.out.println("======================================");

        //只获取当前类中所有定义的属性，不区分访问权限
        Field[] fields1 = clazz.getDeclaredFields();
        for (Field field:fields1){
            System.out.println(field);
            //各部分分开获取
            System.out.println("访问修饰符："+Modifier.toString(field.getModifiers()));
            System.out.println("属性名称："+field.getType().getSimpleName());
            System.out.println("属性名："+field.getName());
        }
    }
    /**
     * 获取方法的所有信息
     */
    @Test
    public void getClassForMethod() throws Exception {
        //获取Class对象
        Class<Person> clazz = Person.class;
        //获取所有public修饰的方法
        Method[] methods = clazz.getMethods();
        for (Method method:methods){
            System.out.println(method);
        }
        System.out.println("===============================");
        //获取当前类中所有方法
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method method:declaredMethods){
            System.out.println(method);
            System.out.println("访问修饰符："+Modifier.toString(method.getModifiers()));
            System.out.println("返回类型："+method.getReturnType().getSimpleName());
            System.out.println("方法名："+method.getName());
            System.out.println("参数个数："+method.getParameterCount());
            System.out.println("参数类型："+Arrays.toString(method.getParameterTypes()));
        }
        System.out.println("=======================================");
        //获取单个方法
        Method method = clazz.getDeclaredMethod("setPersonName", String.class);
        //通过反射实例化一个对象
        Person instance = clazz.newInstance();
        //开启方法访问权限
        method.setAccessible(true);
        //通过反射钓鱼用实例中对应的方法
        method.invoke(instance,"张三");
        //获取值,注意需要再获取getPersonName方法
        method = clazz.getDeclaredMethod("getPersonName");
        //因为getPersonName方法是public，所以不需要开启访问权限，直接拿值
        Object value = method.invoke(instance);
        System.out.println(value);

    }
    /**
     * 获取类中的构造方法信息
     */
    @Test
    public void getClassForConstructor() throws Exception {
        //获取Class对象
        Class<Person> clazz = Person.class;
        //获取所有public修饰的构造方法
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor constructor:constructors){
            System.out.println(constructor);
        }
        System.out.println("=====================================");
        //获取类中所有的定义的构造方法
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor constructor:declaredConstructors){
            System.out.println(constructor);
            System.out.println("访问修饰符："+Modifier.toString(constructor.getModifiers()));
            System.out.println("构造方法名："+constructor.getName());
            System.out.println("参数列表："+Arrays.toString(constructor.getParameterTypes()));
            System.out.println("-------------------------");
        }
        //获取类中指定的构造方法
        Constructor<Person> constructor = clazz.getDeclaredConstructor(int.class, String.class);
        constructor.setAccessible(true);
        Person instance = constructor.newInstance(19, "李四");
        System.out.println(instance);
    }
    /**
     * 利用反射暴力访问类中的私有属性
     */
    @Test
    public void testAccessPrivate() throws Exception {
        //获取Class对象
        Class<Person> clazz = Person.class;
        //获取到Person对象的实例
        Object instance = clazz.newInstance();
        //单独获取到personId字段
        Field personIdField = clazz.getDeclaredField("personId");
        //设置字段访问权限
        personIdField.setAccessible(true);
        //调用字段对应的set方法
        personIdField.set(instance,23);
        //获取刚刚设置的字段中的值
        Object value = personIdField.get(instance);
        System.out.println(value);
    }
}