反射

概述：在运行期间，可以获取对象的类型、类型的方法、类型的属性、类型构造方法等等
让对象可以认识到自身的结构

获取对象的类型(类对象)

方式1：Object .getClass()
方式2： Class.forName(“类名”)
方式3： 类名.class

类对象的功能

1) 用反射方式创建对象

正常创建对象: new 类名();
反射创建对象: 类对象.newInstance(); // 创建一个新实例(对象)

2) 获取方法信息

类对象.getMethods(); // 获取所有公共方法（public），包括继承的
类对象.getDeclaredMethods(); // 获取本类的所有方法(public, private, protected, 不加)

类对象.getMethod(方法名, 参数类型); // 找公共方法， 包括继承的
类对象.getDeclaredMethod(方法名, 参数类型); // 找本类的，不包括继承的

3）获取属性信息

类对象.getFields(); // 获取所有公共属性（包括继承的）
类对象.getDeclaredFields(); // 获取本类所有属性（private public protected 不加）（不包括继承的）
类对象.getField(“属性名”);
类对象.getDeclaredField(“属性名”);

4) 获取构造方法

类对象.getConstructors(); // 获取所有公共的构造方法
类对象.getDeclaredConstructors(); // 获取本类所有构造方法（private public protected 不加）
类对象.getConstructor(int.class); // 获取int参数类型的构造
类对象.getConstructor(); // 获得无参构造

5） 反射调用方法

正常调用方式： 对象.方法名(参数)
反射调用方式： 方法.invoke(对象， 参数);
缺点：调用复杂，效率低
优点：可以调用私有方法，突破正常方法的限制, 经常用在开源框架中

public class User {
    private String name;
    private int age;

    public User() {

    }

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

    private void m1(){
        System.out.println("m1被执行了");
    }
    public void m1(int num){
        System.out.println("m1(int num)被执行了");
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Student {
    private Student(){
        System.out.println("私有构造被调用了");
    }
}
public class TestReflect {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //方法一：
        System.out.println(new User().getClass());
        //方法二：
        System.out.println(Class.forName("reflect.User"));
        //方法三：
        System.out.println(User.class);
        System.out.println(new User().getClass() == Class.forName("reflect.User"));
        System.out.println(Class.forName("reflect.User") == User.class);

        // 反射创建对象, newInstance() 限制1： 要求对象有无参构造  限制2： 构造方法不能私有
        User user = User.class.newInstance();
        System.out.println(user);
        System.out.println("----------------------------------------------------------");
        //获取方法信息
        Method[] methods = User.class.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

//        Method m1 = User.class.getMethod("m1");
//        System.out.println(m1);
        System.out.println("----------------------------------------------------------");
        Field[] fields = User.class.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("----------------------------------------------------------");
        User u = new User();
        //u.m1();   正常调用

        // 方法.invoke(对象， 参数);
        Method m1 = User.class.getDeclaredMethod("m1");
        m1.setAccessible(true);
        m1.invoke(u);

        //放射调用
        Method m11 = User.class.getDeclaredMethod("m1",int.class);
        m11.invoke(u,1);

        //调用私有构造
        Constructor<Student> constructor = Student.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Student student = constructor.newInstance();
        System.out.println(student);
    }
}