反射

什么是反射？

• 反射是指在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性；这种动态获取信息及动态调用方法的功能成为Java的反射机制。

反射的作用

• 利用Java机制，在Java程序中可以动态的去调用一些protected甚至是private的方法或类，这样就可以在很大程度上满足一些特殊需求。

• 在Android SDK的源码中，很多类或方法中经常加上了“@hide”注释标记，它的作用是使这个方法或类在生成SDK时不可见，所以程序可能无法编译通过，而且在最终发布的时候，就可能存在一些问题。对于这种问题，第一种方法就是自己去掉源码中的“@hide”标记，然后在重新编译生成一个SDK。另一种方法就是使用Java反射机制，利用反射机制可以访问存在访问权限的方法或修改其访问域。

• 可能有人会有疑问，明明直接new对象就好了，为什么非要用反射呢？代码量不是反而增加了？其实反射的初衷不是方便你去创建一个对象，而是让你在写代码的时候可以更加灵活，降低耦合，提高代码的自适应能力。

• Class类
  Class是一个类，封装了当前对象所对应的类的信息
  一个类中有属性，方法，构造器等，比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是Class，它应该有类名，属性，方法，构造器等，Class是用来描述类的类。
  Class类是一个对象照镜子的结果，对象可以看到自己有哪些属性，方法，构造器，实现了哪些接口等等。
  对于每个类而言，JRE都为其保留一个不变的Class类型的对象，一个Class对象包含了特定某个类的有关信息。
  对象只能由系统建立对象，一个类在JVM中只会有一个Class实例
  获取Class对象的三种方式
  1.通过类名获取 类名.class
  2.通过对象获取 对象名.getClss()
  3.通过全类名获取 Class.forName(全类名)

  
  Class类的常用方法.png

ClassLoader加载

类装载器是用来把类(class)装载进 JVM 的。JVM 规范定义了两种类型的类装载器：启动类装载器(bootstrap)和用户自定义装载器(user-defined class loader)。 JVM在运行时会产生3个类加载器组成的初始化加载器层次结构

classLoader.png

   //获取系统的类加载器
    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
    System.out.print(classLoader);

    //2. 获取系统类加载器的父类加载器（扩展类加载器，可以获取）.
    classLoader = classLoader.getParent();
    System.out.println(classLoader);


    //3. 获取扩展类加载器的父类加载器（引导类加载器，不可获取）.
    classLoader = classLoader.getParent();
    System.out.println(classLoader);

    classLoader = Class.forName("com.ycl.myjavabase.refle.Person").getClassLoader();

    System.out.println(classLoader);

    //5. 测试 JDK 提供的 Object 类由哪个类加载器负责加载（引导类）
    classLoader = Class.forName("java.lang.Object")
            .getClassLoader();
    System.out.println(classLoader);

Java反射机制主要提供了以下功能

在运行时构造任意一个类的对象
在运行时获取任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法（属性）
生成动态代理
Person测试类

public class Person {

 String name;
private int age;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
    System.out.print("this is name");
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
    System.out.println("this is setAge()!");
}

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

public Person() {
    super();
}

//私有方法
private void priMethod(){
    System.out.println("this is private method!");
}

}

testMethod

public static void testMethod() throws Exception {

    Class<?> clazz = Class.forName("com.ycl.myjavabase.refle.Person");

    System.out.println("获取clazz对应类中的所有方法，" +
            "不能获取private方法,且获取从父类继承来的所有方法");
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        System.out.println("" + method.getName() + "");
    }
    System.out.println("---------------------------");

    System.out.println("获取所有方法，包括私有方法，" +
            "所有声明的方法，都可以获取到，且只获取当前类的方法");

    methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
        System.out.println("" + method.getName() + "");
    }
    System.out.println("---------------------------");

    System.out.println("获取指定的方法，" +
            "需要参数名称和参数列表，无参则不需要写");


    Method method = clazz.getDeclaredMethod("setName", String.class);
    System.out.println(method);
    System.out.println("---");
    //  方法public void setAge(int age) {  }
    /* 这样写是获取不到的，如果方法的参数类型是int型
    如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) {  }
    要么获取方法的参数写成int.class*/

    method = clazz.getDeclaredMethod("setAge", int.class);
    System.out.println(method);
    System.out.println("-----------------");

    System.out.println("执行方法，第一个参数表示执行哪个对象的方法" +
            "，剩下的参数是执行方法时需要传入的参数");

    Object obj = clazz.newInstance();

    method.invoke(obj, 20);

    /*私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;*/
    method = clazz.getDeclaredMethod("priMethod");
    System.out.println(method);
    System.out.println("---------------------------");
    System.out.println("执行私有方法");
    method.setAccessible(true);
    method.invoke(obj);


}

Constructor

public static void testConstructor() throws Exception {

    Class<?> clazz = Class.forName("com.ycl.myjavabase.refle.Person");

    System.out.println("获取全部Constructor对象-----");

    Constructor<?>[] constructors = clazz.getConstructors();

    for (Constructor constructor : constructors) {
        System.out.println(constructor);
    }

    System.out.println("获取某一个Constructor 对象，需要参数列表----");

    Constructor<Person> constructor = (Constructor<Person>) clazz.getConstructor(String.class, int.class);
    System.out.println(constructor);

    System.out.println("调用构造器的 newInstance() 方法创建对象-----");

    Person person = constructor.newInstance("ycl", 18);

    System.out.println(person.getName() + "--" + person.getAge());

}

Field
public static void testField() throws Exception {

    Class<Person> clazz = (Class<Person>) Class.forName("com.ycl.myjavabase.refle.Person");
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        System.out.print(field.getName());
    }
    System.out.println();
    System.out.println("---------------------------");

    System.out.println("获取指定字段");

    Field field = clazz.getDeclaredField("name");

    System.out.println(field.getName());

    Person person = new Person("ycl", 20);
    System.out.println("获取指定字段的值");

    Object obj = field.get(person);
    System.out.println(person.getAge() + "==" + obj);

    System.out.println("设置指定字段的值");
    field.set(person,"AAA");
    System.out.println(obj+"=="+person.getName());

    System.out.println("字段是私有的，不管是读值还是写值，" +
            "都必须先调用setAccessible（true）方法");
    //     比如Person类中，字段name字段是非私有的，age是私有的
    field = clazz.getDeclaredField("age");
    field.setAccessible(true);
    System.out.println(field.get(person));

}

参考文章
https://juejin.cn/post/6844903663966617607
https://www.jianshu.com/p/9dad553ecd05
https://blog.csdn.net/qq_36226453/article/details/82790375
https://www.cnblogs.com/adamjwh/p/9683705.html