Java-反射

Java中类的加载器和反射

参考文章：https://blog.csdn.net/One_L_Star/article/details/96696266

一、类加载器

负责将 .class 文件加载到内存中，并为之生成对应的 class 对象

1、类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三个步骤来实现对这个类进行初始化

加载：将 class 文件读入内存，并为之创建一个 class 对象，任何类被使用时系统都会建立一个 class 对象
连接：验证是否有正确的内部结构，并和其他类协调一致，为类的静态成员分配内存，并设置默认初始化值，将类的二进制数据中的符号引用替换为直接引用
初始化：创建对象等

2、类初始化时机（何时加载到内存中）

创建类的实例对象时
类的静态变量或为静态变量赋值
类的静态方法
使用反射方式来强制某个类或接口对应的 java.lang.Class 对象
直接使用 java.exe 命令来运行某个主类

3、类加载器的组成

Bootstrap ClassLoader：根类加载器，也被称为引导类加载器，负责Java核心类的加载，如：System，String等
Extension ClassLoader：扩展类加载器，负责JRE的扩展目录中jar包的加载
System ClassLoader：系统类加载器，负责在jvm启动时加载来自Java命令的class文件，以及classpath环境变量所指定的jar包和类路径

二、反射

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

2.1 反射原理步骤

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

2.2 获取一个类的 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);
}

2.3 获取class 文件中的成员

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

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);
}

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

Constructor 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);
}

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

被反射的类必须有空参构造函数
构造方法必须是 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);
}

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

不推荐，破坏了程序的封装性和安全性
Constructor getConstructor()：获取指定参数的构造方法
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);
}

(5) 反射获得成员变量并修改

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 C = Class.forName("myFansheClass.Person");
    System.out.println(C);
 
    //反射获得公共成员变量
    //获取成员变量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);
    }
}

(6) 反射获得成员方法并运行

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);
}

(7) 反射泛型擦除

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

当我们正常的将 Activity 对象放进 list中去，IDE会给出错误：

List<String> list = new ArrayList<>();
list.add("Hello");
list.add(this); // List cannot be applied to XXXActivity.

显然，泛型的约束让我们无法将 Activity 对象放进泛型为 String 的集合中去。

我们可以看下编译后的XXXActivity.class

ArrayList list = new ArrayList<>();
list.add("Hello");

可以看到之前 java 代码里对 List 中的元素只能为 String 的泛型代码没了，这就是泛型擦除。那么也就是说泛型的约束是在编译时约束的，真正运行的 class 是没有泛型约束的，那么想解决题目的话，只要在运行时将 Activity 对象加入就好了，那么自然想到反射，我们来尝试下：

List<String> mList = new ArrayList();
mList .add("Hello");

try{
    Field field = getClass().getDeclaredField("mList");
    field.setAccessible(true);
    List list = (List) field.get(this);
    list.add(this);
} catch (NoSuchFieldException e) {
    e.printStackTrace();
} catch (IllegalAccessException e) {
    e.printStackTrace();
}

(8) 反射通过配置文件运行实现

现有三个类：Student 类、Techer 类、Worker 类，为了方便对代码的修改，将类名和方法名写入配置文件，使用反射的方法来运行

步骤如下：

准备配置文件，写入键值对
IO流读取配置文件内容
将文件中的键值对存储到集合 properties 中
反射指定类的 class 文件对象
通过 class 文件对象获取指定方法
运行方法

/**
 * 【1】 准备配置文件，写入键值对
 * 【2】 IO流读取配置文件内容
 * 【3】 将文件中的键值对存储到集合 properties 中
 * 【4】 反射指定类的 class 文件对象
 * 【5】 通过 class 文件对象获取指定方法
 * 【6】 运行方法
 */
public static void main(String[] args) throws Exception{
    //【1】 准备配置文件，写入键值对
    //【2】 IO流读取配置文件内容
    FileReader FR = new FileReader("config.properties");
    //【3】 将文件中的键值对存储到集合 properties 中
    Properties Pro = new Properties();
    //【3.1】传递流对象
    Pro.load(FR);
    FR.close();
    //【3.2】获取键值对
    String className = Pro.getProperty("ClassName");
    String methodName = Pro.getProperty("MethodName");
    //【4】 反射指定类的 class 文件对象
    Class C = Class.forName(className);
    Object obj = C.newInstance();
    //【5】 通过 class 文件对象获取指定方法
    Method meth = C.getMethod(methodName);
    //【6】 运行方法
    meth.invoke(obj);
}

posted @ 2021-04-12 19:12 废熊阅读(86) 评论(0) 收藏举报

刷新页面返回顶部

废熊