反射API操作属性、方法、构造器

个人对反射的理解:

　　反射是在运行中，可以获取一个类的所有属性和方法，并且可以操作该类的所有属性和方法。

　　和new关键字不同，new关键字无法获取private修饰的属性和方法及构造器，但是反射能；在使用new关键字时，不知道类名是无法new的，但是反射在不知道类名时也可以使用，这也是spring框架中的控制反转（IOC）的核心机制。

正文：

　　一、首先创建一个beanDemo:

package fanShe;

public class User {

    private int id;
    public String name;
    private int age;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setId() {
        this.id = 1;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    public User() {
        
    }
    
    
}

　　二、使用反射API对bean的属性、方法、构造器进行操作

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Demo01 {
    
    public static void main(String[] args) {
        String path = "fanShe.User";
        try {
            //反射
            Class clazz = Class.forName(path);
            //获取包名+类名
            System.out.println(clazz.getName());
            //获取类名
            System.out.println(clazz.getSimpleName());
            
            /**
             * 获取属性
             */
            //获取只能是public的属性
            Field[] fields = clazz.getFields();
            System.out.println(fields.length);
            //获取类下所有的属性（包括私有属性）
            Field[] declaredFields = clazz.getDeclaredFields();
            System.out.println(declaredFields.length);
            for (Field field : declaredFields) {
                System.out.println(field);
            }
            
            /**
             * 获取方法
             */
            //获取该类的所有的public的方法，包括默认继承的Object类
            Method[] methods = clazz.getMethods();
            System.out.println(methods.length);
            //获取该类的所有的方法(不包括构造方法和Object的方法)
            Method[] declaredMethods = clazz.getDeclaredMethods();
            for (Method method : declaredMethods) {
                System.out.println(method);
            }
            System.out.println(declaredMethods.length);
            //获取指定的方法（第一个参数为方法名称，第二个参数为该方法中的参数类型，如果没有就填null，目的是防止重载找不到目标方法）
            clazz.getDeclaredMethod("setId", int.class);
            
            /**
             * 获取构造器
             */
            //获取该类的public的构造器
            Constructor[] constructors = clazz.getConstructors();
            System.out.println(constructors.length);
            //获取该类下的所有构造器
            Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
            for (Constructor constructor : declaredConstructors) {
                System.out.println(constructor);
            }
            //获取指定的构造器（参数为该构造器中的参数的类型，如果该构造器没有参数，则填null）
            Constructor declaredConstructor = clazz.getDeclaredConstructor(int.class,String.class,int.class);
            System.out.println(declaredConstructor);
            
            
            /**
             * 通过反射API调用构造方法，构造对象
             */
            User user1 = (User) clazz.newInstance(); //调用类的无参构造
            System.out.println(user1);
            //获取指定的构造器后，可通过newInstance传入具体的值给对象进行赋值
            User user2 = (User) declaredConstructor.newInstance(10,"张三丰",20);
            //赋值后可调用方法获取数据
            System.out.println(user2.getName());
            //动态获取方法
            Method declaredMethod = clazz.getDeclaredMethod("setName", String.class);
            declaredMethod.invoke(user2, "丰是");    //通过方法给该属性赋值
            System.out.println(user2.getName());
            
            /**
             * 通过反射API操作属性
             */
            User user3 = (User) clazz.newInstance(); //调用类的无参构造
            Field field = clazz.getDeclaredField("age");
            field.setAccessible(true); //因为私有的属性是不能被操作的，但是反射有办法，将该属性设置为不必检查，可以直接访问
            field.set(user3, 18);    //通过反射写属性
            System.out.println(user3.getAge());    //普通方法调用
            System.out.println(field.get(user3));//通过反射API调用
            
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}