Java中类的加载器和反射

目录

一、类加载器

1、类的加载

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

3、类加载器的组成

二、反射

1、反射原理步骤

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

3、获取class 文件中的成员

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

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

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

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

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

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

(7) 反射泛型擦除

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

---

一、类加载器

• 负责将 .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语言的反射机制

1、反射原理步骤

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

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

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

(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) 反射泛型擦除

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

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

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