【Java】一文搞定Java反射技术_class c1=class.forname class c2=demo.class-优快云博客

本文深入讲解Java反射机制，包括类加载器的工作原理，反射的基本概念，如何通过反射获取类的构造方法、成员变量和成员方法，以及反射在泛型擦除和配置文件运行功能中的应用。

Java基础之反射

一、类加载器
二、反射
- 1.Class类
- 2.通过反射获取构造方法并使用
三、反射练习
- 1.泛型擦除
- 2.反射通过配置文件运行功能的实现

一、类加载器

1.类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三个步骤来实现对这个类进行初始化。
加载
- 就是指将class文件读入内存，并为之建立一个Class对象。
- 任何类被使用时系统都会建立一个Class对象。
连接
- 验证：是否有正确的内部结构，并且和其他类协调一致。
- 准备：负责为类的静态成员分配内存，并设置默认的初始化值。
- 解析：将类的二进制数据中的符号引用替换为直接引用。
初始化

2.类的加载时机（进入内存）

直接使用java.exe命令来运行某个主类。
创建类的实例（new对象）。
使用类的静态变量，或者为静态变量赋值。
调用类的静态方法。
初始化某个类的子类，其父类先进入内存。
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。

最先进入内存的类是Object类，并且最先执行的方法并不是main方法，二十Object类中的registerNatives()，将对象注册在操作系统上。

3.类加载器

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

4.类加载器的组成

Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载（jre的lib目录下rt.jar）。
Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载（ext文件夹下）。
System ClassLoader 系统类加载器
负责在JVM启动时在加载来自java命令的class文件，以及第三方jar文件。

二、反射

1.Class类

获取Class对象的三种方式

通过Object类中的getClass()方法。
通过类名.class获取到字节码文件对象（任意数据类型都具备一个class静态属性）。
通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName()即可）。字符串必须是包名加类名。

代码演示（假定有一个类Person，通过三种方法获取Person类的class文件对象）

package cn.mrzhang.demo1;

/**
 * 获取一个类的class文件对象的三种方式：
 *      1.对象获取
 *      2.类名获取
 *      3.Class类静态方法获取
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.对象获取
        Person person = new Person();
        //调用Person类的父类方法getClass()  返回Person的class文件的对象
        Class c1 = person.getClass();
        //c表示Person类的class文件的文件对象，打印出带着包名的全类名
        System.out.println(c1);

        //2.类名获取
        //每个类型，包括基本和引用，都会赋予这个类型一个静态的属性，属性名字叫class
        Class c2 = Person.class;
        System.out.println(c2);
        System.out.println(c1==c2);

        //3.Class静态方法获取
        Class c3 = Class.forName("cn.mrzhang.demo1.Person");
        System.out.println(c3);
        System.out.println(c1==c3);
    }
}

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

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

获取一个构造方法：
- public Constructor getConstructor()
获取多个构造方法：
- public Constructor<?>[] getConstructors()
执行其public构造方法：
- 使用Constructor类中的newInstance()方法。
快捷创建对象实例的方法：
- 调用Class类中的newInstance()方法。
- 前提：被反射的类必须具有无参构造，无参构造必须为public。
获取所有public成员变量：
- 调用Class类的方法getFields()，返回值为Field[]，Field类为表述成员变量对象的类。
获取指定public成员变量：
- 调用Class类的方法getField(字符串类型的变量名)，返回值为Field。
- 赋值：public void set(Object obj, Object value)
- 获取值：public Object get(Object obj)
获取所有public成员方法：
- 调用Class类的方法getMethods()，返回值为Method[]，Method类为表述成员方法对象的类。
获取指定public成员方法：
- 调用Class类的方法getMethod(字符串类型的方法名，class … c)，返回值为Method。
执行其private构造方法，获取私有成员变量，执行私有成员方法（暴力私有）：
- 调用Constructor类的父类AccessibleObject的方法setAccessible（boolean b）方法，布尔值为true，则可以执行。值为true时，指示反射的对象在使用时取消Java语言的方法检查，则可以执行私有构造方法。
- getDeclaredConstructor(Class … c)
- getDeclaredField()
- getDeclaredMethod(“字符串类型成员方法名称”，方法参数列表的class文件对象)
- 注意事项：不推荐使用反射获取私有的构造方法并执行，因为其破坏了程序的封装性与安全性。
代码演示（反射获取Person类的所有构造方法与无参数构造方法）

package cn.mrzhang.demo1;

import java.lang.reflect.Constructor;

/**
 * 通过反射获取class文件中的构造方法，运行构造方法
 * 通过运行构造方法，从而创建对象
 *
 * 步骤：
 *      1.获取class文件对象
 *      2.从class文件对象中，获取需要的成员
 *
 *  Constructor描述构造方法对象类
 */
public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("cn.mrzhang.demo1.Person");
        //使用class文件对象获取类中所有的构造方法
        // Constructor[] getConstructors()  获取class文件对象中的所有public构造方法
        Constructor[] cons = c.getConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        
        //获取一个指定的构造方法
        Constructor constructor = c.getConstructor();
        System.out.println(constructor);
        //运行空参构造方法，Constructor类方法newInstance()运行获取到的构造方法
        Object obj = constructor.newInstance();
        System.out.println(obj.toString());
        //通过强制转换为Person类对象,则可调用其变量和方法。
        Person p = (Person)obj;
    }
}

代码演示（反射获取Person类的指定构造方法并且执行）

package cn.mrzhang.demo1;

import java.lang.reflect.Constructor;

/**
 * 通过反射，获取有参数构造方法并且执行
 */
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
        //获取带有String，String，int参数的构造方法
        //Constructor<T> getConstructor ( Class<?> ... parameterTypes)
        //Class<?> ... parameterTypes 传递要获取的构造方法的参数列表
        Constructor<?> con = c1.getConstructor(String.class, String.class, int.class);
        System.out.println(con);
        //执行构造方法
        //使用Constructor类中的newInstance(Object ... initargs)方法，括号内为传递的实际参数
        Object obj = con.newInstance("小明", "男", 20);
        System.out.println(obj);
    }
}

代码演示（反射获取Person类构造方法并执行，简便方法）

package cn.mrzhang.demo1;

/**
 * 反射获取构造方法并执行（快捷）
 *  前提：
 *      1.被反射的类必须具有无参构造
 *      2.无参构造必须为public
 *
 *  Class类中的方法：
 *      newInstance()
 *          直接创建被反射的类的对象实例，
 *          不需要使用Constructor类中的getConstructor()方法获取构造方法
 */
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception{
        Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
        //调用方法newInstance()
        Object obj = c1.newInstance();
        System.out.println(obj);
    }
}

代码演示（反射获取Person类的成员变量并修改值）

package cn.mrzhang.demo1;

import java.lang.reflect.Field;

/**
 * 反射获取成员变量值，并修改值
 *  Class类中的方法：
 *      1.getFields()，返回值为Field[]
 *          获取所有成员变量，Field类为表述成员变量的类
 *      2.getField(字符串类型的变量名)，返回值为Field
 *          获取指定成员变量
 *  Field类中的方法：
 *      1.void set(Object obj,Object value)
 *          用来修改成员变量，前者为对象，后者为值
 */
public class ReflectDemo4 {
    public static void main(String[] args) throws Exception{
        Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
        Object obj = c1.newInstance();
        //获取所有成员变量
        Field[] fields = c1.getFields();
        for (Field f : fields){
            System.out.println(f);
        }
        //获取指定成员变量
        Field name = c1.getField("name");
        System.out.println(name);
        //修改成员变量值
        name.set(obj,"小红");
        System.out.println(obj);
    }
}

代码演示（反射获取Person类的无参数成员方法并执行）

package cn.mrzhang.demo1;

import java.lang.reflect.Method;

/**
 * 反射获取无参数成员方法并运行
 *  步骤：
 *      1.获取class对象中所有的public成员方法
 *          Method[] getMethods() 获取的是class文件中所有的成员方法，包括继承的方法
 *          Method类是描述成员方法的对象
 *      2.获取class对象中指定的public成员方法
 *          Method getMethod("字符串类型的方法名"，参数列表)
 *      3.执行，使用Method类中的方法，运行所获取的方法
 *          Object invoke(Object obj , Object ... o)
 */
public class ReflectDemo5 {
    public static void main(String[] args) throws Exception{
        Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
        //创建类的对象
        Object obj = c1.newInstance();
        //获取所有成员方法
        Method[] methods = c1.getMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
        System.out.println("----------------------");
        //获取指定成员方法
        Method fun1 = c1.getMethod("fun1");
        System.out.println(fun1);
        //执行成员方法
        fun1.invoke(obj);
    }
}

代码演示（反射获取Person类的有参数成员方法并执行）

package cn.mrzhang.demo1;

import java.lang.reflect.Method;

/**
 * 反射获取有参数成员方法并执行
 */
public class ReflectDemo6 {
    public static void main(String[] args) throws Exception{
        Class<?> c1 = Class.forName("cn.mrzhang.demo1.Person");
        //创建对象实例
        Object obj = c1.newInstance();
        //获取指定方法
        Method setAge = c1.getMethod("setAge", int.class);
        System.out.println(setAge);
        //执行方法
        Object o = setAge.invoke(obj, 20);
        Person p = (Person)obj;
        System.out.println(p.getAge());
    }
}

三、反射练习

1.泛型擦除

定义集合类，泛型String，要求向集合中添加Integer类型。
- 集合类的泛型为String，向集合添加Integer类型数据会编译失败。
- 伪泛型：编译后的class文件是没有泛型的。
- 想法：绕过泛型，直接调用class文件中的add方法。
- 步骤：
1. 获取ArrayList类的class文件对象。
2. 获取ArrayList.class文件中的方法add()。
3. 向其中添加字符串元素。

package cn.mrzhang.demo1;

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * 泛型擦除
 *  定义集合类，泛型String
 *  要求向集合中添加Integer类型
 */
public class Demo7 {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        //获取ArrayList类的class文件对象
        Class<? extends ArrayList> c1 = list.getClass();
        //获取ArrayList.class文件中的方法add()
        Method add = c1.getMethod("add",Object.class);
        System.out.println(add);
        //向其中添加字符串元素
        add.invoke(list,1);
        System.out.println(list);
    }
}

2.反射通过配置文件运行功能的实现

调用某类的某个方法，不清楚哪个类的哪个方法。
通过配置文件实现此功能：
- 运行的类名与方法名，以键值对的形式写在文本中。
- 运行哪个类，读取配置文件即可。
实现步骤：
1. 准备配置文件，键值对的形式。
2. IO流读取配置文件 Reader。
3. 将文件中的键值对存储到集合中Properties（集合中保存的键值对就是要运行的类名与方法）。
4. 反射获取指定类的class文件对象。
5. 通过class文件对象，获取指定的方法。
6. 运行方法。

package cn.mrzhang.demo2;
//测试类1
public class Person {
    public void eat(){
        System.out.println("人在吃饭");
    }
}

package cn.mrzhang.demo2;
//测试类2
public class Student {
    public void study(){
        System.out.println("学生在学习");
    }
}

package cn.mrzhang.demo2;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 调用3个类中一个类的方法
 *  不清楚调用哪个类中的哪个方法，不能修改代码
 *
 *      通过配置文件实现此功能
 *          运行的类名与方法名，以键值对的形式写在文本中
 *          运行哪个类，读取配置文件即可
 *      实现步骤：
 *          1.准备配置文件，键值对的形式
 *          2.IO流读取配置文件 Reader
 *          3.将文件中的键值对存储到集合中Properties
 *              集合中保存的键值对就是要运行的类名与方法名
 *          4.反射获取指定类的class文件对象
 *          5.通过class文件对象，获取指定的方法
 *          6.运行方法
 */
public class TestDemo2 {
    public static void main(String[] args) throws Exception {
        //IO流读取配置文件
        InputStream resourceAsStream = TestDemo2.class.getClassLoader().getResourceAsStream("config.properties");
        //创建集合对象
        Properties p = new Properties();
        //调用方法load传递流对象
        p.load(resourceAsStream);
        //释放流对象
        resourceAsStream.close();
        //通过键获取值
        String className = p.getProperty("className");
        String methodName = p.getProperty("methodName");
        //反射获取指定类的class文件对象
        Class<?> c1 = Class.forName(className);
        Object obj = c1.newInstance();
        //反射获取指定的方法
        Method method = c1.getMethod(methodName);
        //执行方法
        method.invoke(obj);
    }
}

配置文件(config.properties)：

className=cn.mrzhang.demo2.Student
methodName=study
#className=cn.mrzhang.demo2.Person
#methodName=job

运行结果：