本文共 12716 字，大约阅读时间需要 42 分钟。

有一段时间没有接触反射了，Java Web学的越深，深刻认识到反射的重要性，所以今天抽空来复习一下反射，记录如下。

类加载器

类的加载

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

1. 加载
   就是指将class文件读入内存，并为之创建一个Class类型的对象。任何类被使用时系统(JVM)都会建立一个Class类型的对象。
2. 连接
   • 验证：验证加载进来的文件是否有正确的内部结构，并和其他类协调一致。
   • 准备：负责为类的静态成员分配内存，并设置默认初始化值。
   • 解析：将类的二进制数据中的符号引用替换为直接引用。(说的是啥意思？？？)
3. 初始化
   这是我们所做的事情，也即我们以前讲过的初始化步骤。

类加载的时机(类什么时候加载到内存中去)

1. 创建某个类的实例(new 对象)
2. 调用类的静态成员变量或者为静态成员变量赋值
3. 调用类的静态方法
4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
5. 创建子类对象也会把父类加载到内存
6. 直接使用java.exe命令来运行某个主类

类加载器

类加载器的作用是负责将class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。下面来粗略讲解一下类加载器的组成。

• Bootstrap ClassLoader
  根类加载器，也被称为引导类加载器，负责Java核心类库(rt.jar)的加载，比如System、String等，Java核心类库——rt.jar在JRE的lib目录下，如下图：
  
• Extension ClassLoader
  扩展类加载器，其负责JRE的扩展目录中jar包的加载，即加载JRE下面的ext文件夹下面的jar包，如下图：
  
• System ClassLoader
  系统类加载器，其负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。用大白话来说就是系统类加载器加载我们自己写的类。

通过这些描述就可以知道我们常用的类，都是由谁来加载完成的。到目前为止我们已经知道把class文件加载到内存了，那么，如果我们仅仅站在这些class文件的角度，我们如何来使用这些class文件中的内容呢？这就是我们要研究的内容——反射了。

反射

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

从以上的这段话中，我们可以抽取出这样两个结论：

1. 反射定义
   能够在运行时期获得和调用类或者对象的成员变量，成员方法以及构造方法。
2. 反射条件
   一定是在运行时期。

所以，要想解剖一个类，必须先要获取到该类的字节码文件对象，而解剖使用的就是Class类中的方法，故先要获取到每一个字节码文件对应的Class类型的对象。

Class类

阅读API的Class类得知，Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

获取一个类的class文件对象有三种方式，下面我们分别来讲解。在讲解之前，我们要事先做好准备，可以创建好这样一个Java类——Person.java：

public class Person {    public String name;    private int age;    public Person(){    }    public Person(String name, int age){        this.name = name;        this.age = age;    }    private Person(int age,String name){        this.name = name;        this.age = age;    }    public void eat(){        System.out.println("人吃饭");    }    public void sleep(String s, int a,double d){        System.out.println("人在睡觉"+s+"....."+a+"....."+d);    }    private void playGame(){        System.out.println("人在打游戏");    }    public String toString() {        return "Person [name=" + name + ", age=" + age + "]";    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

获取一个类的class文件对象的第一种方式：通过该类的对象的getClass()方法获得。例如：

Person p = new Person();// 调用Person类的父类的方法getClass()Class c = p.getClass();

第二种方式：通过类名.class获取到字节码文件对象（任意数据类型都具备一个class静态属性，看上去要比第一种方式简单）。例如：

// 每个类型包括基本的和引用的，都会赋予这个类型一个静态的属性，属性名字就叫classClass c1 = Person.class;

第三种方式：通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。例如：

// Class类的静态方法获取 forName(字符串类名) 字符串类名：包名.类名(类全名)Class c2 = Class.forName("cn.itcast.demo1.Person");

注意：第三种和前两种的区别：

• 前两种你必须明确是Person类型。
• 第三种是指定这种类型的字符串就行。这种扩展性更强，我不需要知道你的类，我只提供字符串，按照配置文件加载就可以了。

通过反射获取构造方法并使用

在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示，可通过Class类中提供的方法获取构造方法：

• 返回一个构造方法
  • public Constructor<T> getConstructor(Class<?>... parameterTypes)
    获取public修饰，指定参数类型所对应的构造方法。
  • public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
    获取指定参数类型所对应的构造方法(包含私有的)。
• 返回多个构造方法
  • public Constructor<?>[] getConstructors()
    获取所有的public修饰的构造方法。
  • public Constructor<?>[] getDeclaredConstructors()
    获取所有的构造方法(包含私有的)。

获取构造方法的代码演示：

public class ReflectDemo1 {    public static void main(String[] args) throws Exception {        // 获取Class类型的对象        Class c = Class.forName("cn.itcast.demo1.Person");        // 使用class文件对象，获取类中所有的构造方法(包括私有的)        Constructor[] cons = c.getDeclaredConstructors();        for (Constructor con : cons) {            System.out.println(con);        }        System.out.println("--------------------------------------------");        // 获取一个指定的构造方法，即空参数的构造方法        // public Person() {}        Constructor con1 = c.getConstructor();        System.out.println(con1);        // 获取String、int参数的构造方法：public Person(String name, int age) {}        // Constructor
   
     getConstructor(Class
    ... parameterTypes)          // Class
    ... parameterTypes：传递要获取的构造方法的参数列表        Constructor con2 = c.getConstructor(String.class, int.class);        System.out.println(con2);        // Constructor getDeclaredConstructor(Class... c)：获取到指定参数列表的构造方法(包括私有的)        Constructor con3 = c.getDeclaredConstructor(int.class, String.class);        System.out.println(con3);    }}
   

通过反射方式，获取构造方法，创建对象

获取构造方法，步骤如下：

1. 获取到Class对象
2. 获取指定的构造方法
3. 通过构造方法类Constructor中的方法——public T newInstance(Object... initargs)，创建对象

代码示例演示：

• 通过反射获取class文件中的空参数构造方法，并运行该空参数构造方法

  public class ConstructorDemo {    public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        // 获取一个指定的构造方法，即空参数的构造方法        Constructor con = c.getConstructor();        // 运行空参数的构造方法，        // Constructor类中的方法newInstance运行获取到的构造方法        Object obj = con.newInstance();        System.out.println(obj.toString());    }}

  提示：通过反射获取class文件中的空参数构造方法并运行，还有一个快捷的方式，但使用此方式有两个前提：

  1. 被反射的类，必须具有空参数的构造方法。
  2. 构造方法权限必须是public的。

  代码示例演示如下：

  public class ConstructorDemo {    public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        // Class类中定义了一个方法：public T newInstance()，直接创建被反射类的对象实例        Object obj = c.newInstance();        System.out.println(obj);    }}

• 通过反射获取有参数的构造方法并运行

  public class ConstructorDemo1 {    public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        // 获取String、int参数的构造方法        // Constructor
       
         getConstructor(Class
        ... parameterTypes)          // Class
        ... parameterTypes：传递要获取的构造方法的参数列表        Constructor con = c.getConstructor(String.class, int.class);        // 运行构造方法        // T newInstance(Object... initargs)          // Object... initargs：运行构造方法后，传递的实际参数        Object obj = con.newInstance("张三", 20);        System.out.println(obj);    }}
       

通过反射方式，获取私有构造方法，创建对象

AccessibleObject类是Field、Method和Constructor对象的父类。它提供了将反射的对象标记为在使用时取消默认Java语言访问控制检查的能力。说了半天，其实我也不知这句话什么意思！反正写在这儿，以待后面探讨。

对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用Field、Method或Constructor对象来设置或获取字段、调用方法或者创建和初始化类的新实例的时候，会执行访问检查。常用方法如下：

• public void setAccessible(boolean flag) throws SecurityException
  参数值为true，则指示反射的对象在使用时应该取消Java语言访问检查。参数值为false，则指示反射的对象应该实施Java语言访问检查。

获取私有构造方法，步骤如下：

1. 获取到Class对象
2. 获取指定的构造方法
3. 暴力访问，通过setAccessible(boolean flag)方法
4. 通过构造方法类Constructor中的方法——public T newInstance(Object... initargs)，创建对象

代码示例演示如下：

public class ConstructorDemo2 {    public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        // Constructor getDeclaredConstructor(Class... c)：获取到指定参数列表的构造方法(包括私有的)             Constructor con = c.getDeclaredConstructor(int.class, String.class);        // Constructor类有一个父类AccessibleObject，父类中定义了一个方法：void setAccessible(boolean flag)         con.setAccessible(true); // 暴力反射        Object obj = con.newInstance(20, "李四");        System.out.println(obj);    }}

这就是通常所说的暴力反射，不过我们一般不推荐这么做，因为它破坏了程序的封装性和安全性。

通过反射获取成员变量并使用

在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：

• 返回一个成员变量
  • public Field getField(String name)
    获取指定的public修饰的变量。
  • public Field getDeclaredField(String name)
    获取指定的任意变量。
• 返回多个成员变量
  • public Field[] getFields()
    获取所有public修饰的变量。
  • public Field[] getDeclaredFields()
    获取所有的变量(包含私有)。

获取成员变量的代码演示：

public class FieldDemo {    public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        // 获得class文件中的所有的成员变量        Field[] fields =  c.getDeclaredFields();        for (Field field : fields) {            System.out.println(field);        }        System.out.println("----------------------------------");        // 获取指定的成员变量String name        // Class类的方法：Field getField(传递字符串类型的变量名)，获取指定的成员变量        Field nameField = c.getField("name");        System.out.println(nameField);    }}

通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作

获取成员变量，步骤如下：

1. 获取Class对象
2. 获取构造方法
3. 通过构造方法，创建对象
4. 获取指定的成员变量（私有成员变量，通过setAccessible(boolean flag)方法暴力访问）
5. 通过方法，给指定对象的指定成员变量赋值或者获取值
   • public void set(Object obj, Object value)
     在指定对象obj中，将此Field对象表示的成员变量设置为指定的新值。
   • public Object get(Object obj)
     返回指定对象obj中，此Field对象表示的成员变量的值。

示例代码演示：

/** * 通过反射获取成员变量，并修改值 * Person类中的成员String name * @author 李阿昀 * */public class FieldDemo1 {
       public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        Object obj = c.newInstance();        // 获取指定的成员变量String name        // Class类的方法：Field getField(传递字符串类型的变量名) 获取指定的成员变量        Field field = c.getField("name");        // Field类的方法： void set(Object obj, Object value)可以修改成员变量的值        // Object obj：必须有对象的支持；Object value：修改后的值        field.set(obj, "王五");        System.out.println(obj);    }}

通过反射获取成员方法并使用

在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法：

• 返回获取一个方法
  • public Method getMethod(String name, Class<?>... parameterTypes)
    获取public修饰的方法。
  • public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
    获取任意的方法，包含私有的。
    参数1：name，即要查找的方法名称；参数2：parameterTypes，即该方法的参数类型。
• 返回获取多个方法
  • public Method[] getMethods()
    获取本类与父类中所有public修饰的方法。
  • public Method[] getDeclaredMethods()
    获取本类中所有的方法(包含私有的)。

获取成员方法的代码演示：

public class MethodDemo {    public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        // 获取class文件中的所有成员方法，包括继承的        Method[] methods = c.getDeclaredMethods();        for (Method method : methods) {            System.out.println(method);        }        System.out.println("--------------------------");        // 获取指定的方法eat               // Method getMethod(String methodName, Class... c)        // String methodName：你想要获取的方法名；Class... c：方法的参数列表        Method method = c.getMethod("eat");        System.out.println(method);    }}

通过反射，创建对象，调用指定的方法

获取成员方法，步骤如下：

1. 获取Class对象
2. 获取构造方法
3. 通过构造方法，创建对象
4. 获取指定的方法
5. 执行找到的方法
   • public Object invoke(Object obj, Object... args)
     执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。

示例代码演示如下：

/** * 反射获取有参数的成员方法并运行 * public void sleep(String s, int a, double d) {} * @author 李阿昀 * */public class MethodDemo1 {
       public static void main(String[] args) throws Exception {        Class c = Class.forName("cn.itcast.demo1.Person");        Object obj = c.newInstance();        // 调用Class类的方法getMethod()获取指定的方法sleep        Method method = c.getMethod("sleep", String.class, int.class, double.class);        // 调用Method类的invoke方法运行sleep方法        method.invoke(obj, "休眠", 100, 888.99);    }}

反射练习

泛型擦除

现在夜已深了，而我却还在做笔记，哎！好了，来思考这样一个问题：向已存在的ArrayList<String>集合中添加一个Ingeter类型的数据，如何实现呢？如果还是按照之前那样写代码，肯定是不行的，这用屁股想就可以了，而现在我们学了反射技术，想都不用想，就该知道要使用到反射这门技术了。

我来告诉大家，其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素。例如：

public class ReflectTest {    public static void main(String[] args) throws Exception {        ArrayList
   
     array = new ArrayList
    
     ();        array.add("a");        // array.add(1);        // 反射的方式，获取出集合ArrayList类的class文件对象        Class c = array.getClass();        // 获取ArrayList.class文件中的方法add        Method method = c.getMethod("add", Object.class);        // System.out.println(method);        // 使用invoke运行ArrayList方法add        method.invoke(array, 150);        method.invoke(array, 1500);        method.invoke(array, 15000);        System.out.println(array);    }}
    
   

通过以上案例，我们可以更好地理解反射。

反射配置文件

假设此刻我们拥有如下三个Java类：

• Person.java

  public class Person {    public void eat() {        System.out.println("人在吃饭");    }}

• Student.java

  public class Student {    public void study() {        System.out.println("学生在学习");    }}

• Worker.java

  public class Worker {    public void job() {        System.out.println("上班族在工作");    }}

现在我们有如下一个测试类——Test.java：

public class Test {    public static void main(String[] args) throws Exception {        ...    }}

在以上测试类中我们有时需要调用Person对象的方法，有时需要调用Student对象的方法，也有时需要调用Work对象的方法。类不清楚，方法也不清楚，并且项目一旦完工，交付客户之后，我们是无法再去修改测试类中的源码的。此时我们可

• 反射配置文件，运行配置文件中指定类的对应方法。

  读取config.properties文件中的数据，通过反射技术，来完成Person对象的创建。config.properties文件的内容如下：

  #className=cn.itcast.demo3.Student#methodName=studyclassName=cn.itcast.demo3.PersonmethodName=eat#className=cn.itcast.demo3.Worker#methodName=job

• 读取配置文件，调用指定类中的对应方法

  public class Test {    public static void main(String[] args) throws Exception {        // Person p = new Person();        // p.eat();        // IO流读取配置文件        FileReader r = new FileReader("config.properties");        // 创建集合对象        Properties pro = new Properties();        // 调用集合方法load，传递流对象        pro.load(r);        r.close();        // 通过键获取值        String className = pro.getProperty("className");        String methodName = pro.getProperty("methodName");        // 反射获取指定类的class文件对象        Class c = Class.forName(className);        Object obj = c.newInstance();        // 获取指定的方法名        Method method = c.getMethod(methodName);        method.invoke(obj);    }}

转载地址：https://liayun.blog.csdn.net/article/details/56989869 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！