Java通过反射访问类的成员属性，构造方法，成员方法

反射

1.获取类的字节码文件对象

1. Object类的getClass方法：通过类对象获取类的字节码文件对象

        Student s = new Student();
        Class clazz = s.getClass();

2. 类的class属性：通过类名.class获取类的字节码文件对象

		Class clazz = Student.class;

3. Class类的forName方法：通过类的全限定名称获取类的字节码文件对象

		Class clazz = Class.forName("com.qf.Test_01.Student");

2.通过反射访问类的成员属性

//学生类
public class Student {
    public String name;
    private int age;
    String gender;
    
    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    private Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

	public void show() {
        System.out.println("love 57");
    }
    private void method(String name) {
        System.out.println("marry with "+name);
    }
}

//测试类代码
//通过反射获取单个属性并赋值

		Class clazz = Class.forName("com.qf.Test_01.Student");
        //通过Class类的newInstance()获取类的实例
        Object obj = clazz.newInstance();

        //getField() 获取Student类的public的属性
        Field nameField = clazz.getField("name");
        //getDeclaredField() 获取Student类的任意属性
        Field ageField = clazz.getDeclaredField("age");
        Field genderField = clazz.getDeclaredField("gender");

		//set(Object obj,Object value):给绑定在当前对象上的字段进行赋值
        nameField.set(obj,"高圆圆");
        
        //age是私有的，setAccessible(true) 取消java语言的访问检查
        ageField.setAccessible(true);
        ageField.set(obj,42);
        
        //gender是默认修饰符，不取消Java语言的访问检查也可对其赋值
        genderField.set(obj,"女");
        
        System.out.println(obj);

        // 获取所有的公共的成员变量Field
        Field[] fields = clazz.getFields() ;
        // 这包括公共，受保护，默认（包）访问和私有字段，但不包括继承的字段。
        Field[] declaredFields = clazz.getDeclaredFields();

        for (Field field : fields) {
            System.out.println(field);
        }
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

3.通过反射获取类的构造器并成员属性赋值

		//获取类的字节码文件对象
        Class clazz = Class.forName("com.qf.Test_01.Student");
		
		/*通过类的字节码文件对象获取public类的构造器，
		  getConstructor()获取指定的公共的单个的构造器对象
		  参数:当前参数类型的字节码文件对象 */
        Constructor constructor = clazz.getConstructor(String.class,int.class,String.class);
        //通过构造器创建类的实例对象并赋值
        Object obj = constructor.newInstance("高圆圆",42,"女");

		//getDeclaredConstructor()获取指定的任意类的构造器对象
		Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class,int.class);
		//此处的构造器是私有的，需要取消Java语言的访问检查
        declaredConstructor.setAccessible(true);
        Object obj2 = declaredConstructor.newInstance("赵又廷", 45);
        System.out.println(obj2);

		//获取所有public构造器对象数组
        Constructor[] constructors = clazz.getConstructors();
		//获取所有类的构造器对象数组
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor constructor1 : constructors) {
            System.out.println(constructor1);
        }
        for (Constructor declaredConstructor1 : declaredConstructors) {
            System.out.println(declaredConstructor1);
        }
		
		

        System.out.println(obj);

4.通过反射访问类的成员方法

        Class clazz = Class.forName("com.qf.Test_01.Student");
        Object obj = clazz.newInstance();

		//获取所有的成员方法:公共的(包含他父类的所有的公共的方法)
        Method show = clazz.getMethod("show");
        //public Object invoke(Object obj,Object... args):将方法的实际参数绑定在当前类实例上
        //参数1:就是当前类的实例
        //参数2:可变参数, 方法传递实际参数  若无参,则实际不用传递
        //返回值:如果当前方法本身有返回值,则返回Object
        show.invoke(obj);
		
		//获取所有的成员方法:包括私有,默认,受保护,继承父类的方法
        Method method = clazz.getDeclaredMethod("method", String.class);
        //取消Java语言的访问检查
        method.setAccessible(true);
        method.invoke(obj, "57");

		//获取类的成员方法数组
		Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }