反射

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

反射是java中非常重要的机制，使得我们能够在程序运行过程中创建、修改、调用对象，也是许许多多框架的基础。

反射原理步骤

类加载到内存
加载器自动为.class 文件创建一个对象
在自己的程序中获取到.class 文件

获取一个类的 class 文件对象的三种方式

以获取Person类的class文件对象为例，这三种方法获得的都是同一个对象

对象获取：调用 Person 类的父类方法 getClass()
类名获取：每个类型，包括基本类型和引用类型，都会赋予这个类型一个静态的属性，属性名字为class
Class 类的静态方法获取：Class 类的静态方法获取forName（字符串的类名）包名.类名

public static void main(String[] args) throws ClassNotFoundException {
    //1.对象获取，调用Person类的父类方法 getClass()
    Person P = new Person();
    Class C = P.getClass();
    System.out.println(C);
 
    //2.类名获取
    Class C1 = Person.class;
    System.out.println(C1);
 
    //3.类的静态方法获取
    Class C2 = Class.forName("myFansheClass.Person");
    System.out.println(C2);
}

获取class 文件中的成员

使用反射获取无参的构造方法并运行

Constructor getConstructor()：获取指定的空参构造方法
Constructor[] getConstructors()：获取class文件对象中的所有公共的构造方法，返回的是构造方法的数组
newInstance()：运行空参构造函数，返回Object类型的实例

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //类的静态方法获取
    Class C = Class.forName("myFansheClass.Person");
    System.out.println(C);
 
    //获取class文件对象中的所有公共的构造方法
    Constructor[] Cons = C.getConstructors();
    for(Constructor con : Cons)
    {
        System.out.println(con);
    }
 
    //获取指定的构造方法，空参的
    Constructor Co = C.getConstructor();
    System.out.println(Co);
 
    //运行空参构造方法，赋值给父类object多态调用
    Object obj = Co.newInstance();
    System.out.println(obj);
 
    //将obj强转即可调用Person类中的方法和变量
    Person p = (Person)obj;
    p.Study();
    System.out.println(p.age);
}

使用反射获取有参的构造方法并运行

Constructor<T> getConstructor(Class<?>... parameterTypes)：获得指定的构造方法，传递要获取的构造方法的参数列表，根据参数的类型获取构造方法
Object newInstance(Class<?>... parameterTypes)：运行构造方法，传递可变参数

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //类的静态方法获取
    Class C = Class.forName("myFansheClass.Person");
    System.out.println(C);
 
    //Constructor<T> getConstructor(Class<?>... parameterTypes)获取构造方法
    Constructor Con = C.getConstructor(String.class,int.class);
    System.out.println(Con);
 
    //运行构造方法，传递可变参数
    Object obj = Con.newInstance("Tom",18);
    System.out.println(obj);
}

反射获取构造方法并运行的快捷方式

被反射的类必须有空参构造函数
构造方法必须是 public 权限

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //类的静态方法获取
    Class C = Class.forName("myFansheClass.Person");
    System.out.println(C);
 
    //反射获取构造方法并运行的快捷方式
    Object obj = C2.newInstance();
    System.out.println(obj);
}

反射获取私有构造方法并运行（暴力反射）

不推荐，破坏了程序的封装性和安全性
Constructor getConstructor(Class<?>... parameterTypes)：获取指定参数的构造方法
Constructor类的父类AccessibleObject类的方法setAccessible(boolean b)，参数为true的时候能取消访问检查

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //类的静态方法获取
    Class C = Class.forName("myFansheClass.Person");
    System.out.println(C);
 
    //反射获取私有构造方法并运行
    //1、Constructor getConstructor()获取指定参数的构造方法
    Constructor con = C.getDeclaredConstructor(int.class,String.class);
    //2、Constructor类的父类AccessibleObject类的方法setAccessible(boolean b)，参数为true的时候能取消访问检查
    con.setAccessible(true);
 
    Object obj = con.newInstance(12,"Tim");
    System.out.println(obj);
}

反射获得成员变量并修改

Field[] getFields()：获取成员变量Class类的方法getFields() class文件中所有公共的成员变量，返回 Field[] 数组，Field 类是描述类成员变量的类
Field[] getField()：获取指定的成员变量，通过 set() 方法来修改对象的成员变量
Field[] getDeclaredFields()：获得私有成员变量

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //类的静态方法获取
    Class C2 = Class.forName("myFansheClass.Person");
    System.out.println(C2);
 
    //反射获得公共成员变量
    //获取成员变量Class类的方法getFields() class文件中所有公共的成员变量，返回 Field[] 数组，Field 类是描述类成员变量的类
    Field[] Fies = C2.getFields();
    for(Field Fie : Fies)
    {
        System.out.println(Fie);
    }
 
    //反射获得指定成员变量并修改
    Object obj = C2.newInstance();  //反射创建对象
    Field Fie = C2.getField("age");    //获取指定成员变量
    System.out.println(Fie);
    Fie.set(obj,12);    //修改指定成员变量
    System.out.println(obj);
 
    //反射获得私有成员变量
    Field[] Fies1 = C2.getDeclaredFields();
    for(Field Fie1 : Fies1)
    {
        System.out.println(Fie1);
    }
}

反射获得成员方法并运行

Method[] getMethods()：获得class文件中所有公共成员方法，Method 类是描述成员方法的类
Method getMethod(String name, Class<?>... parameterTypes)：获得指定成员方法，name为要获取的方法名，parameterTypes为参数列表
meth.invoke(obj)：运行方法：使用Method类中的方法

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //类的静态方法获取
    Class C = Class.forName("myFansheClass.Person");
    System.out.println(C);
 
    //反射获得成员方法
    //Method[] getMethods()获得class文件中所有公共成员方法，Method 类是描述成员方法的类
    Method[] meths = C2.getMethods();
    for(Method meth : meths)
    {
        System.out.println(meth);
    }
 
    Object obj = C2.newInstance();
    //获取指定的公共成员方法
    // Method getMethod(String name, Class<?>... parameterTypes):name为要获取的方法名，parameterTypes为参数列表
    Method meth = C2.getMethod("Study");
    //运行方法：使用Method类中的方法
    // Object invoke(Object obj, Object... args)：
    meth.invoke(obj);
}

反射泛型擦除

使用反射，可以将类中的成员解刨在开发人员面前，任由改动，比如对于一个用泛型限定了的数组，可以使用反射来存储泛型之外的内容

public static void main(String[] args) throws Exception {
    ArrayList<Integer> list = new ArrayList<>();
    //调用父类的 getClass()方法
    Class C = list.getClass();
    //获取指定的成员方法
    Method meth = C.getMethod("add",Object.class);
    //运行方法
    meth.invoke(list,"oneStar");
    meth.invoke(list,"twoStar");
    meth.invoke(list,"threeStar");
    System.out.println(list);
}