反射（reflect）

清疚 2023-09-28 09:11 70阅读 0赞

**目录**

反射（reflect）

Java中的反射相关知识点

反射的基本操作步骤：

获取一个Class对象的反射API

探究一个Class对象的反射API

总结一下

使用探究到的信息的反射API

--------------------

### 反射（reflect） ###

反射：*在运行时探究和使用编译时未知的类*。

很明显在这句话中有两个时：运行时、编译时。根据我们的开发流程，都是先书写一个类，然后在代码里面产生它的对象，调用它的方法或属性，然后编译！编译结束以后，再运行，就能看到相应的效果---所以这是一个先编译后运行的流程。

但是反射这句话把整个过程给颠倒了，我们在是运行起来以后，才知道我们要产生哪个类的对象，调用它的哪个方法或属性。

举个例子，比如：IDEA这个软件就是用Java写的，它在运行起来以后可以探究到我们自己在它运行之后才编译好的Student类里面有哪些属性和行为，然后让我们通过联想的方式可以看到。

这就是Java语言提供的动态性效果。这里的动态性指的是“运行”起来以后，对应的“静态性”不是static而是编译后运行前。

编程语言分为：动态语言和静态语言。动态语言可以在程序运行起来之后，给它的类增加或修改或减少属性和行为。当然，Java作为静态语言做不到。 Java虽然不是动态语言，但是它具有一定的动态性。这个动态性就体现在“反射”上，虽然它没有办法在运行期给类增加/修改/删除成员内容，但是它可以探究和使用，而这就是反射提供的效果。

### Java中的反射相关知识点 ###

Java的工作流程：

1、先编写Java源文件；

2、然后编译Java原文件为class文件；

3、运行，而运行又分为3步：

3-1、加载

3-2、校验

3-3、解释执行

“反射”在这几个过程中和“加载”的关系很密切，所以我们要再深入“加载”来聊一聊。

1、加载谁？ 2、谁加载？ 3、加载成什么？

**第一个问题**：加载的是class文件。细节在于：一个Java类就会编译成一篇class文件，那么加载class文件就是在加载这个类，所以这个过程也叫做“类加载”；

**第二个问题**：在JVM当中，提供了一种叫做“类加载器”的东西，来完成加载这个动作。“类加载器”也叫做ClassLoader，它是JDK当中已经写好了的，提供给JVM用来做加载动作的。 Java在这里还专门设计了一个叫做“双亲委托模型”的东西。Java的类加载提供了三种加载器，如果再加上我们自定义的，那就是4种：

BootstrapClassLoader、ExtClassLoader、ApplicationClassLoad、最后自定义的。

在加载的过程中： BootstrapClassLoader负责加载的是JDK中的那些最基本常用的类； ExtClassLoader负责加载的是jre/lib/ext这个包里面的常用类； ApplicationClassLoader是加载我们在应用层面自己写的类。

加载的方式是：向上询问，向下负责。

**第三个问题**：class文件是一篇字节码文件，那么到了内存当中，它是什么形式呢？它被加载成了一个对象。这个对象的类型是Class类型的，所以也被叫做Class对象。

Class对象是专门用来装一个类的内容信息的。一个类只需要一个Class对象。所以，在这句代码中其实产生了两个对象：

Student stu = new Student();

1、new出来的，交给stu去指向的，是Student的**“实例对象”**；表示一个学生对象，里面是该学生的数据和它可以执行的行为；

2、但是实例对象是**运行期**产生的，而在它之前需要先加载Student这个类，那么就会产生一个**Class对象**，在它当中装的是Student类的内容信息，包括：这个类的名字、父类是谁、接口有哪些、放在哪个包、有什么属性、构造、行为.....所以这个Class对象又被叫做**“类模版对象”**。

3、类模版对象和实例对象的关系

3-1、必须先有模版对象，然后才能有实例对象；

3-2、模版对象只需要1个，实例对象可以根据要求产生无数个。

3-3、理论上，模版对象是JVM使用的，用来记载这个类的信息；而实例对象是我们的应用程序用的，用来装载数据和具体调用方法完成功能实现的。

反射在做什么事情呢？反射其实就是通过获取这个类的Class对象，我们就能够知道这个类的信息（探究），拿到这些信息以后，比如：拿到它的构造方法的信息，我们就可以产生实例对象了；拿到它的属性信息，我们就可以给属性进行赋值取值了；这就是所谓的“使用”。当然前提条件是获取它的Class对象。

### 反射的基本操作步骤： ###

1.  **获取**一个**类**的**Class对象**；
2.  通过**Class对象**完成一个类的信息的探究。主要是探究3个东西：**构造、属性和行为**；
3.  探究到以后，就可以使用这些信息了。**探究到构造就可以产生实例对象；探究到属性就可以对属性赋值取值；探究到方法就可以调用。**

#### 获取一个Class对象的反射API ####

方式1、类型名.class

*注意* ： 所有的类型（包括void）都有Class对象； 基本数据类型可以通过自己.class，也能通过自己的包装类.TYPE 获取到该基本类型的Class对象； 不管用哪种方式（包括后面的方式二和方式三）获取Class对象，同一类型的只有一个Class对象。

示例：

//1、可以根据类型名的标识符获取Class对象
            //   所有的Java类型都可以通过这种方式获取它的Class对象
            Class stuClass = StudentBean.class;//自定义的Java类的Class对象
            Class strClass = String.class;
            Class interClass = Serializable.class;//接口的Class对象
            Class intArrayClass = int[].class;
            Class stuArrayClass = StudentBean[].class;
            Class intClass = int.class;//基本数据类型的Class对象
            Class intClass2 = Integer.TYPE;//也是基本数据类型int的Class对象
            /*
                在JDK5之前，由于Java要体现基本数据类型只能装数据，而不能有任何"."
                出来的内容。所以，在语法设计的时候不允许用"int"点出任何内容。那么要
                获取int的Class的对象，就只能通过int对应的包装类来实现。
                但是包装类.class得到的是包装类的Class对象；所以又给每个包装类设计
                了一个TYPE，用于专门获得对应的基本数据类型的Class对象。
                所以：Integer.class和Integer.TYPE得到的是不同的Class对象。
             */
            //System.out.println(intClass2 == intClass);//结果为false
            Class voidClass = void.class;//甚至连void也有Class对象。

方式2、实例对象.getClass()

*注意* ：getClass()来自于Object，所以只有Objet的子类才可以通过这种方式获取；接口、基本数据类型、void都不能通过这种方式获取它们的Class对象。

示例：

//2、通过实例对象的getClass()方法获取到Class对象
           
            StudentBean stu = new StudentBean("zhang3",18);//StudentBean的实例对象
            Class stuClass1 = stu.getClass();
            Class stuClass = StudentBean.class
            // System.out.println(stuClass == stuClass1);//结果为true
            Class strClass1 = "hello".getClass();
            Class strClass2 = "world".getClass();
            int[] intArray = {1,3,5,7,9};
            Class intArrayClass1 = intArray.getClass();

方式3、Class.forName(类型的字符串名称)

*注意* ：这种方式是需要做异常处理的，因为有可能这个字符串对应的类型找不到，所以forName方法抛出了一个编译时异常ClassNotFoundException。 这种方式只能获取类、接口、数组的Class对象，不支持基本数据类型和void。 其中数组的字符串类名有古怪：

Student\[\] --> "\[Lcom.lovo.bean.Student"

Serializable\[\] --> "\[Ljava.io.Serializable"

byte\[\] "\[B"

short\[\] "\[S"

int\[\] "\[I"

long\[\] "\[J" -- 特殊

float\[\] "\[F"

double\[\] "\[D"

char\[\] "\[C"

boolean\[\] "\[Z" -- 特殊

示例：

//3、通过字符串形式的类型名获取Class对象
            try {
                Class stuClass3 = Class.forName("com.project.bean.StudentBean");
                Class strClass4 = Class.forName("java.lang.String");
                Class interClass2 = Class.forName("java.io.Serializable");
                Class intArrayClass2 = Class.forName("[I");
                Class intClass1 = Class.forName("void");
                int[] intArray = {1,2,3,4,5};
                Class intArrayClass1 = intArray.getClass;
                System.out.println(intArrayClass2 == intArrayClass1);//结果为true
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

最后，我们需要对比一下这三种方式： 方式1 是可以获取所有的Java类型； 方式2 只能获取Object的子类类型； 方式3 可以获取所有的引用数据类型。

除了方式3，其他两种方式都*没有*“动态性”。

示例：

String str = new Scanner(System.in).next();
            try {
                /*
                    Class.forName在编译的时候并不知道要获取谁的Class对象；
                    JVM也不知道要创建谁的Class对象。
                    而是运行起来以后，根据传入的str的值，才能确定要加载谁，
                    然后把谁的Class对象交给c。
                    这才是有动态性的反射代码。
                 */
                Class c = Class.forName(str);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

#### 探究一个Class对象的反射API ####

探究类的基本信息：

String className = stuClass.getName();//得到类的全名--类的限定名
            System.out.println(className);
            className = stuClass.getSimpleName();//得到类的简单名
            System.out.println(className);
            Class superClass = stuClass.getSuperclass();//得到父类的Class对象
            String superName = superClass.getName();
            System.out.println("父类名：" + superName);
            Class[] interClasses = stuClass.getInterfaces();//得到这个类实现的接口的Class对象
            System.out.println("接口名：");
            for(Class interC : interClasses){
                System.out.println(interC.getName());
            }
            Package aPackage = stuClass.getPackage();//得到类所在的包信息
            System.out.println("所在包：" + aPackage.getName());

探究构造方法

getConstructors() -- 获取所有的公共构造

getDeclaredConstructors() -- 获取所有声明的构造

这两个方法都是返回的Constructor\[\]。

getConstructor(参数的class对象) -- 获取指定的公共构造 getDeclaredConstructor(参数的class对象) -- 获取指定的声明构造

示例：

Constructor[] allPublicCons = stuClass.getConstructors();//获取所有的公共构造
            Constructor[] allCons = stuClass.getDeclaredConstructors();//获取所有的构造
            Constructor publicCon = stuClass.getConstructor(String.class,int.class);//获取指定的某一    个公共构造
            Constructor theCon = stuClass.getDeclaredConstructor(String.class);//获取某个指定的声明构造与访问修饰符无关
    
            for(Constructor con : allCons){
                String conName = con.getName();//构造方法的名字是"类的限定名"
                int modNum = con.getModifiers();//构造方法的修饰符
                String modStr = Modifier.toString(modNum);
                Parameter[] params = con.getParameters();//构造方法的参数
                String strParams = "";
                for(int i = 0; i < params.length; i++){
                    String parmStr = params[i].getType().getName();//得到参数的类型
                    String parmName = params[i].getName();
                    strParams += parmStr + " " + parmName;
                    if(i != params.length - 1){
                        strParams +=",";
                    }
                }
                System.out.println(modStr + " " + conName + "(" + strParams + ")");
            }

探究属性

getFields() -- 获取所有的公共属性

getDeclaredFields() -- 获取所有声明的属性

getField(属性名) -- 获取某个指定的公共属性

getDeclaredField(属性名) -- 获取某个指定的申明属性

示例：

Field[] allPublicFields = stuClass.getFields();//获取所有的公共属性
            Field[] allFields = stuClass.getDeclaredFields();//获取所有的申明属性
            Field publicF = stuClass.getField("id");//获取指定的公共属性
            Field theF = stuClass.getDeclaredField("CLASSNAME");//获取某一个指定的申明属性

探究方法

getMethods() -- 获取所有的公共方法

getDeclaredMethods() -- 获取所有声明的方法

getMethod(方法名,参数的class对象) -- 获取某个指定的公共方法

getDeclaredMethod(方法名,参数的class对象) -- 获取某个指定的声明方法

示例：

Method theM = stuClass.getDeclaredMethod("setName",String.class);

#### 总结一下 ####

这里的探究告诉了我们，在一个类的Class对象里面封装好了这个类的所有信息（只要你在类的代码里面声明的东西，都可以获取到）。 当然对我们最有意义的，最常用的，就是获取构造、属性和方法的那3组12个get。不要死记，其实就是4个单词和单复数的区别。

#### 使用探究到的信息的反射API ####

探究到构造，就要产生实例对象

Constructor对象有一个叫做newInstance的方法，通过这个方法可以产生实例对象。

*注意*：

1、获取到的Constructor对象的参数要和newInstance方法中传递的参数匹配！！！--- 这个其实就是形参和实参的匹配关系。

2、由于我们通过getDeclaredConstructor是可以找到这个类所有的构造方法，但是调用newInstance的时候还是要看该构造的访问修饰符。如果调用处与定义的时候规定的访问权限不匹配，仍然不能产生对象成功。会报：IllegalAccessException。

示例：

//先将StudentBean中的公共无参构造访问修饰符设置为private
    Class stuClass = StudentBean.class;
    //Constructor stuCon1 = stuClass.getDeclaredConstructor();//获取私有无参构造
    //StudentBean stu1 = (StudentBean) stuCon1.newInstance();//此处调用这个构造，必然会报异常
    
    Constructor stuCon2 = stuClass.getConstructor(String.class, int.class);
    StudentBean stu2 = (StudentBean) stuCon2.newInstance("zhang3",28);//1、尊重访问修饰符
                                                                      //2、要与获取到的构造匹配参数

探究到属性，就要给这个属性赋值取值

Field对象身上有一个get()/set()的方法，可以给这个属性进行取值/赋值。当然仍然有前提条件，要遵守这个属性定义的访问修饰符。

示例：

//普通属性
            Field f = stuClass.getField("id");
            int stuID = (int)f.get(stu2);//取值
            f.set(stu2,18);//赋值
            //静态属性
            Field f2 = stuClass.getField("CLASSNAME");
            f2.set(null,"公共一班");

探究到方法，就要调用这个方法

Method对象身上有一个invoke()的方法，可以调用这个method。当然仍然有前提条件，要遵守这个方法定义的访问修饰符。

示例：

Method m = stuClass.getMethod("setAge", int.class);
            m.invoke(stu2,23);
    
            Method m2 = stuClass.getMethod("getName");
            String returnName = (String)m2.invoke(stu2);
            System.out.println(returnName);

**总结一下**

Constructor的newInstance、Method的invoke、Field的get/set。在操作的时候要注意以下几点： 1、调用处的位置要和目标定义的访问修饰符保持一致；

2、Method和Field的操作要注意和实例对象的绑定关系。