33--反射

1、反射(Reflection)的概念

1.1 反射的出现背景

Java程序中，所有的对象都有两种类型：编译时类型和运行时类型，而很多时候对象的编译时类型和运行时类型不一致。 Object obj = new String("hello"); obj.getClass();

例如：某些变量或形参的声明类型是Object类型，但是程序却需要调用该对象运行时类型的方法，该方法不是Object中的方法，那么如何解决呢？

解决这个问题，有两种方案：

方案1：在编译和运行时都完全知道类型的具体信息，在这种情况下，我们可以直接先使用instanceof运算符进行判断，再利用强制类型转换符将其转换成运行时类型的变量即可。

方案2：编译时根本无法预知该对象和类的真实信息，程序只能依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射。

1.2 反射概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

从内存加载上看反射：

1.3 Java反射机制研究及应用

Java反射机制提供的功能：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

1.4 反射相关的主要API

java.lang.Class：代表一个类

java.lang.reflect.Method：代表类的方法

java.lang.reflect.Field：代表类的成员变量

java.lang.reflect.Constructor：代表类的构造器

1.5 反射的优缺点

优点：

提高了Java程序的灵活性和扩展性，降低了耦合性，提高自适应能力

允许程序创建和控制任何类的对象，无需提前硬编码目标类

缺点：

反射的性能较低。

反射机制主要应用在对灵活性和扩展性要求很高的系统框架上

反射会模糊程序内部逻辑，可读性较差。

2、理解Class类并获取Class实例

要想解剖一个类，必须先要获取到该类的Class对象。而剖析一个类或用反射解决具体的问题就是使用相关API:

java.lang.Class
java.lang.reflect.*

所以，Class对象是反射的根源。

2.1 理解Class

2.1.1 理论上

在Object类中定义了以下的方法，此方法将被所有子类继承：

public final Class getClass();

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

Class本身也是一个类
Class 对象只能由系统建立对象
一个加载的类在 JVM 中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个 Class 实例所生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

2.1.2 内存结构上

说明：上图中字符串常量池在JDK6中存储在方法区；JDK7及以后，存储在堆空间。

2.2 获取Class类的实例(四种方法)

方式1：要求编译期间已知类型

前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

实例：

Class clazz1 = String.class;

方式2：获取对象的运行时类型

前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象

实例：

Class clazz2 = String.getClass();

方式3：可以获取编译期间未知的类型

前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

实例：

Class clazz3 = Class.forName("java.lang.String");

方式4：其他方式(不做要求)

前提：可以用系统类加载对象或自定义加载器对象加载指定路径下的类型

实例：

Class clazz4 = ClassLoader.getSystemClassLoader().loadClass("java.lang.String");

实体类：

package com.suyv.reflex;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-28 17:08
 * @Description: TODO
 */
public class Student {

    private int id;
    protected String name;
    char sex;
    public String address;

    public Student() {
    }

    protected Student(int id, String name, char sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

    Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    private Student(int id, String name, String address) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.address = address;
    }


    public Student(int id, String name, char sex, String address) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                ", address='" + address + '\'' +
                '}';
    }
}

获取Class类实例：

package com.suyv.reflex;

import org.junit.Test;

import java.lang.reflect.Constructor;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-28 17:08
 * @Description: TODO
 */
public class ReflexTest01 {

    /**
     * @description: 获取Student类对象的几种方式
     * @author: 憨憨浩浩
     * @date: 2023/12/28 17:21
     * @param: []
     * @return: void
     **/
    @Test
    public void Test01() throws ClassNotFoundException {
        // 获取Student的类对象的几种方式
        // 方式1
        Class<?> clazz1 = Class.forName("com.suyv.reflex.Student");
        System.out.println(clazz1);

        // 方式2
        Class<Student> clazz2 = Student.class;
        System.out.println(clazz2);

        // 方式3
        Student stu = new Student();
        Class clazz3 = stu.getClass();
        System.out.println(clazz3);

        // 方式4
        Class clazz4 = ClassLoader.getSystemClassLoader().loadClass("com.suyv.reflex.Student");
        System.out.println(clazz4);

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1 == clazz3);
        System.out.println(clazz1 == clazz4);

    }
}

2.3 哪些类型可以有Class对象

简言之，所有Java类型！

（1）class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类

（2）interface：接口

（3）[]：数组

（4）enum：枚举

（5）annotation：注解@interface

（6）primitive type：基本数据类型

（7）void

举例：

@Test
public void Test02(){
    Class c1 = Object.class;
    Class c2 = Comparable.class;
    Class c3 = String[].class;
    Class c4 = int[][].class;
    Class c5 = ElementType.class;
    Class c6 = Override.class;
    Class c7 = int.class;
    Class c8 = void.class;
    Class c9 = Class.class;

    System.out.println(c1);     // class java.lang.Object
    System.out.println(c2);     // interface java.lang.Comparable
    System.out.println(c3);     // class [Ljava.lang.String;
    System.out.println(c4);     // class [[I
    System.out.println(c5);     // class java.lang.annotation.ElementType
    System.out.println(c6);     // interface java.lang.Override
    System.out.println(c7);     // int
    System.out.println(c8);     // void
    System.out.println(c9);     // class java.lang.Class


    int[] a = new int[10];
    int[] b = new int[100];
    Class c10 = a.getClass();
    Class c11 = b.getClass();
    // 只要元素类型与维度一样，就是同一个Class
    System.out.println(c10 == c11);     // true
}

2.4 Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	调用缺省构造函数，返回该Class对象的一个实例
getName()	返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class [] getInterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()	返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes)	返回一个Method对象，此对象的形参类型为paramType

举例：

@Test
public void Test03() throws Exception{
    // 将全限定类名存储在str中
    String str = "com.suyv.reflex.Student";
    
    // 获取Class实例
    Class clazz = Class.forName(str);
    
    // 创建Student类实例对象
    Object obj = clazz.newInstance();
    
    // 获取属性
    Field field = clazz.getDeclaredField("name");
    
    // 解除权限限制
    field.setAccessible(true);
    
    // 修改name为张三
    field.set(obj, "张三");
    
    // 获取修改后的name值
    Object name = field.get(obj);
    System.out.println(name);
}

3、类的加载与ClassLoader的理解

3.1 类的生命周期

类在内存中完整的生命周期：加载-->使用-->卸载。其中加载过程又分为：装载、链接、初始化三个阶段。

3.2 类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、链接、初始化三个步骤来对该类进行初始化。如果没有意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载。

类的加载又分为三个阶段：

（1）装载（Loading）

将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成

（2）链接（Linking）

①验证Verify：确保加载的类信息符合JVM规范，例如：以cafebabe开头，没有安全方面的问题。

②准备Prepare：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

③解析Resolve：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

（3）初始化（Initialization）

执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

3.3 类加载器（classloader)

3.3.1 类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

3.3.2 类加载器的分类(JDK8为例)

JVM支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。无论类加载器的类型如何划分，在程序中我们最常见的类加载器结构主要是如下情况：

（1）启动类加载器（引导类加载器，Bootstrap ClassLoader）

这个类加载使用C/C++语言实现的，嵌套在JVM内部。获取它的对象时往往返回null
它用来加载Java的核心库（JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径下的内容）。用于提供JVM自身需要的类。
并不继承自java.lang.ClassLoader，没有父加载器。
出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类
加载扩展类和应用程序类加载器，并指定为他们的父类加载器。

（2）扩展类加载器（Extension ClassLoader）

Java语言编写，由sun.misc.Launcher$ExtClassLoader实现。
继承于ClassLoader类
父类加载器为启动类加载器
从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。

（3）应用程序类加载器（系统类加载器，AppClassLoader）

java语言编写，由sun.misc.Launcher$AppClassLoader实现
继承于ClassLoader类
父类加载器为扩展类加载器
它负责加载环境变量classpath或系统属性 java.class.path 指定路径下的类库
应用程序中的类加载器默认是系统类加载器。
它是用户自定义类加载器的默认父加载器
通过ClassLoader的getSystemClassLoader()方法可以获取到该类加载器

（4）用户自定义类加载器（了解）

在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的。在必要时，我们还可以自定义类加载器，来定制类的加载方式。
体现Java语言强大生命力和巨大魅力的关键因素之一便是，Java开发者可以自定义类加载器来实现类库的动态加载，加载源可以是本地的JAR包，也可以是网络上的远程资源。
同时，自定义加载器能够实现应用隔离，例如 Tomcat，Spring等中间件和组件框架都在内部实现了自定义的加载器，并通过自定义加载器隔离不同的组件模块。这种机制比C/C++程序要好太多，想不修改C/C++程序就能为其新增功能，几乎是不可能的，仅仅一个兼容性便能阻挡住所有美好的设想。
自定义类加载器通常需要继承于ClassLoader。

3.3.3 查看某个类的类加载器对象

（1）获取默认的系统类加载器

ClassLoader classloader = ClassLoader.getSystemClassLoader();

（2）查看某个类是哪个类加载器加载的

ClassLoader classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();

//如果是根加载器加载的类，则会得到null

ClassLoader classloader1 = Class.forName("java.lang.Object").getClassLoader();

（3）获取某个类加载器的父加载器

ClassLoader parentClassloader = classloader.getParent();

示例代码：

package com.suyv.reflex;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 11:28
 * @Description: 类加载器的使用
 */
public class ClassLoaderTest {

    @Test
    public void test1(){

        //获取系统类加载器
        ClassLoader classLoader1 = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader1);   // sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取扩展类加载器
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);   // sun.misc.Launcher$ExtClassLoader@28a418fc

        //获取引导类加载器:失败
        ClassLoader classLoader3 = classLoader2.getParent();
        System.out.println(classLoader3);   // null
    }

    @Test
    public void test2() throws ClassNotFoundException {
        //用户自定义的类使用的是系统类加载器加载的。
        Class clazz1 = Student.class;
        ClassLoader classLoader = clazz1.getClassLoader();
        System.out.println(classLoader);    // sun.misc.Launcher$AppClassLoader@18b4aac2

        //对于Java的核心api使用引导类加载器加载
        Class clazz2 = Class.forName("java.lang.String");
        ClassLoader classLoader1 = clazz2.getClassLoader();
        System.out.println(classLoader1);   // null
    }

    /*
     * 需求：通过ClassLoader加载指定的配置文件
     * */
    @Test
    public void test3() throws IOException {
        Properties pros = new Properties();

        //通过类的加载器读取的文件的默认的路径为：当前module下的src下
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("info.properties");

        pros.load(is);

        String name = pros.getProperty("name");
        String pwd = pros.getProperty("password");
        System.out.println(name + ":" +pwd);
    }

    //Properties:处理属性文件
    @Test
    public void test4() throws IOException {
        Properties pros = new Properties();

        //读取的文件的默认路径为：当前的module
        FileInputStream is = new FileInputStream(new File("info.properties"));

        pros.load(is);

        String name = pros.getProperty("name");
        String pwd = pros.getProperty("password");
        System.out.println(name + ":" +pwd);

    }
}

4、反射的基本应用

有了Class对象，能做什么？

4.1 应用1：创建运行时类的对象

这是反射机制应用最多的地方。创建运行时类的对象有两种方式：

方式1：直接调用Class对象的newInstance()方法

要求： 1）类必须有一个无参数的构造器。2）类的构造器的访问权限需要足够。

方式2：通过获取构造器对象来进行实例化

方式一的步骤：

1）获取该类型的Class对象

2）调用Class对象的newInstance()方法创建对象

方式二的步骤：

1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器

2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

3）通过Constructor实例化对象。

如果构造器的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)

示例代码：

package com.suyv.reflex;

import org.junit.Test;

import java.lang.reflect.Constructor;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 12:10
 * @Description: 创建运行时类的对象
 */
public class TestCreateObject {

    @Test
    public void test1() throws Exception{

        Class clazz = Class.forName("com.suyv.reflex.Student");
        // clazz代表com.suyv.reflex.Student类型
        // clazz.newInstance()创建的就是Student的对象
        Object obj = clazz.newInstance();
        System.out.println(obj);
    }

    @Test
    public void test2()throws Exception{
        // 获取Class对象
        Class clazz = Class.forName("com.suyv.reflex.Student");
        /*
         * 获取Student类型中的有参构造
         * 如果构造器有多个，我们通常是根据形参【类型】列表来获取指定的一个构造器的
         * 例如：public Student(String title, int num)
         */
        // 获取构造器对象
        Constructor<?> constructor = clazz.getDeclaredConstructor(int.class,String.class);

        constructor.setAccessible(true);

        // 创建实例对象
        // T newInstance(Object... initargs)  这个Object...是在创建对象时，给有参构造的实参列表
        Object obj = constructor.newInstance(1,"张三");
        System.out.println(obj);
    }
}

4.2 应用2：获取运行时类的完整结构

可以获取：包、修饰符、类型名、父类（包括泛型父类）、父接口（包括泛型父接口）、成员（属性、构造器、方法）、注解（类上的、方法上的、属性上的）。

4.2.1 相关API

//1.实现的全部接口
public Class<?>[] getInterfaces()   
//确定此对象所表示的类或接口实现的接口。 

//2.所继承的父类
public Class<? Super T> getSuperclass()
//返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。

//3.全部的构造器
public Constructor<T>[] getConstructors()
//返回此 Class 对象所表示的类的所有public构造方法。
public Constructor<T>[] getDeclaredConstructors()
//返回此 Class 对象表示的类声明的所有构造方法。

//Constructor类中：
//取得修饰符: 
public int getModifiers();
//取得方法名称: 
public String getName();
//取得参数的类型：
public Class<?>[] getParameterTypes();

//4.全部的方法
public Method[] getDeclaredMethods()
//返回此Class对象所表示的类或接口的全部方法
public Method[] getMethods()  
//返回此Class对象所表示的类或接口的public的方法

//Method类中：
public Class<?> getReturnType()
//取得全部的返回值
public Class<?>[] getParameterTypes()
//取得全部的参数
public int getModifiers()
//取得修饰符
public Class<?>[] getExceptionTypes()
//取得异常信息

//5.全部的Field
public Field[] getFields() 
//返回此Class对象所表示的类或接口的public的Field。
public Field[] getDeclaredFields() 
//返回此Class对象所表示的类或接口的全部Field。

//Field方法中：
public int getModifiers()
//以整数形式返回此Field的修饰符
public Class<?> getType()  
//得到Field的属性类型
public String getName()  
//返回Field的名称。

//6. Annotation相关
get Annotation(Class<T> annotationClass) 
getDeclaredAnnotations() 

//7.泛型相关
//获取父类泛型类型：
Type getGenericSuperclass()
//泛型类型：ParameterizedType
//获取实际的泛型类型参数数组：
getActualTypeArguments()

//8.类所在的包
Package getPackage()

4.2.2 获取所有的属性及相关细节

package com.suyv.reflex;

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 12:24
 * @Description: 属性
 */
public class FieldTest {
    @Test
    public void test1(){

        Class clazz = Student.class;
        //getFields():获取到运行时类本身及其所有的父类中声明为public权限的属性
        Field[] fields = clazz.getFields();

        for(Field f : fields){
            System.out.println(f);
        }

        System.out.println();
        //getDeclaredFields():获取当前运行时类中声明的所有属性
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f);
        }
    }

    // 权限修饰符  变量类型  变量名
    @Test
    public void test2(){
        Class clazz = Student.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        //1.权限修饰符
        /*
         * 0x是十六进制
         * PUBLIC           = 0x00000001;  1    1
         * PRIVATE          = 0x00000002;  2	10
         * PROTECTED        = 0x00000004;  4	100
         * STATIC           = 0x00000008;  8	1000
         * FINAL            = 0x00000010;  16	10000
         * ...
         *
         * 设计的理念，就是用二进制的某一位是1，来代表一种修饰符，整个二进制中只有一位是1，其余都是0
         *
         * mod = 17          0x00000011
         * if ((mod & PUBLIC) != 0)  说明修饰符中有public
         * if ((mod & FINAL) != 0)   说明修饰符中有final
         */
        for(Field f : declaredFields){
            int modifier = f.getModifiers();
            System.out.print(Modifier.toString(modifier) + "\t");
            // 2.数据类型
            Class type = f.getType();
            System.out.print(type.getName() + "\t");

            // 3.变量名
            String fName = f.getName();
            System.out.print(fName);

            System.out.println();
        }
    }
}

4.2.3 获取所有的方法及相关细节

package com.suyv.reflex;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 12:28
 * @Description: 方法
 */
public class MethodTest {
    @Test
    public void test1() {

        Class clazz = Student.class;
        // getMethods():获取到运行时类本身及其所有的父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }

        System.out.println();

        // getDeclaredMethods():获取当前运行时类中声明的所有方法
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m);
        }

    }

    // 注解信息
    // 权限修饰符 返回值类型 方法名(形参类型1 参数1,形参类型2 参数2,...) throws 异常类型1,...{}
    @Test
    public void test2() {
        Class clazz = Student.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            // 1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for (Annotation a : annos) {
                System.out.println(a);
            }

            // 2.权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");

            // 3.返回值类型
            System.out.print(m.getReturnType().getName() + "\t");

            // 4.方法名
            System.out.print(m.getName());
            System.out.print("(");
            // 5.形参列表
            Class[] parameterTypes = m.getParameterTypes();
            if (!(parameterTypes == null && parameterTypes.length == 0)) {
                for (int i = 0; i < parameterTypes.length; i++) {

                    if (i == parameterTypes.length - 1) {
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }

                    System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                }
            }

            System.out.print(")");

            // 6.抛出的异常
            Class[] exceptionTypes = m.getExceptionTypes();
            if (exceptionTypes.length > 0) {
                System.out.print("throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i == exceptionTypes.length - 1) {
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName() + ",");
                }
            }
            System.out.println();
        }
    }
}

4.2.4 获取其他结构(构造器、父类、接口、包、注解等)

package com.suyv.reflex;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Type;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 12:33
 * @Description: TODO
 */
public class OtherTest {

    // 获取当前类中的所有的构造器
    @Test
    public void test1(){
        Class clazz = Student.class;
        Constructor[] cons = clazz.getDeclaredConstructors();
        for(Constructor c :cons){
            System.out.println(c);
        }
    }

    // 获取运行时类的父类
    @Test
    public void test2(){
        Class clazz = Student.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass); //class com.atguigu.java1.Creature
    }

    // 获取运行时类的所在的包
    @Test
    public void test3(){
        Class clazz = Student.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);

    }

    // 获取运行时类的注解
    @Test
    public void test4(){
        Class clazz = Student.class;
        Annotation[] annos = clazz.getAnnotations();
        for (Annotation anno : annos) {
            System.out.println(anno);
        }

    }

    // 获取运行时类所实现的接口
    @Test
    public void test5(){
        Class clazz = Student.class;
        Class[] interfaces = clazz.getInterfaces();
        for (Class anInterface : interfaces) {

            System.out.println(anInterface);
        }
    }

    // 获取运行时类的带泛型的父类
    @Test
    public void test6(){
        Class clazz = Student.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);//com.atguigu.java1.Creature<java.lang.String>
    }
}

4.2.5 小结

在实际的操作中，取得类的信息的操作代码，并不会经常开发。
一定要熟悉java.lang.reflect包的作用，反射机制。

4.3 应用3：调用运行时类的指定结构

4.3.1 调用指定的属性

在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。

（1）获取该类型的Class对象

Class clazz = Class.forName("包.类名");

（2）获取属性对象

Field field = clazz.getDeclaredField("属性名");

（3）如果属性的权限修饰符不是public，那么需要设置属性可访问

field.setAccessible(true);

（4）创建实例对象：如果操作的是非静态属性，需要创建实例对象

Object obj = clazz.newInstance(); //有公共的无参构造

Object obj = 构造器对象.newInstance(实参...);//通过特定构造器对象创建实例对象

（5）设置指定对象obj上此Field的属性内容

field.set(obj,"属性值");

如果操作静态变量，那么实例对象可以省略，用null表示

（6）取得指定对象obj上此Field的属性内容

Object value = field.get(obj);

如果操作静态变量，那么实例对象可以省略，用null表示

示例代码：

package com.suyv.reflect;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 13:09
 * @Description: TODO
 */
public class Student {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
        "id=" + id +
        ", name='" + name + '\'' +
        '}';
    }
}

package com.suyv.reflect;

import java.lang.reflect.Field;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 13:10
 * @Description: TODO
 */
public class TestField {
    public static void main(String[] args)throws Exception {
        //1、获取Student的Class对象
        Class clazz = Class.forName("com.suyv.reflect.Student");

        //2、获取属性对象，例如：id属性
        Field idField = clazz.getDeclaredField("id");

        //3、如果id是私有的等在当前类中不可访问access的，我们需要做如下操作
        idField.setAccessible(true);

        //4、创建实例对象，即，创建Student对象
        Object stu = clazz.newInstance();

        //5、获取属性值
        /*
         * 以前：int 变量= 学生对象.getId()
         * 现在：Object id属性对象.get(学生对象)
         */
        Object value = idField.get(stu);
        System.out.println("id = "+ value);

        //6、设置属性值
        /*
         * 以前：学生对象.setId(值)
         * 现在：id属性对象.set(学生对象,值)
         */
        idField.set(stu, 2);

        value = idField.get(stu);
        System.out.println("id = "+ value);
    }
}

关于setAccessible方法的使用：

Method和Field、Constructor对象都有setAccessible()方法。

setAccessible启动和禁用访问安全检查的开关。

参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。

提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
使得原本无法访问的私有成员也可以访问

参数值为false则指示反射的对象应该实施Java语言访问检查。

4.3.2 调用指定的方法

（1）获取该类型的Class对象

Class clazz = Class.forName("包.类名");

（2）获取方法对象

Method method = clazz.getDeclaredMethod("方法名",方法的形参类型列表);

（3）创建实例对象

Object obj = clazz.newInstance();

（4）调用方法

Object result = method.invoke(obj, 方法的实参值列表);

如果方法的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)

如果方法是静态方法，实例对象也可以省略，用null代替

示例代码：

package com.suyv.reflect;

import org.junit.Test;

import java.lang.reflect.Method;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 13:12
 * @Description: TODO
 */
public class TestMethod {
    @Test
    public void test()throws Exception {
        // 1、获取Student的Class对象
        Class<?> clazz = Class.forName("com.suyv.reflect.Student");

        //2、获取方法对象
        /*
         * 在一个类中，唯一定位到一个方法，需要：（1）方法名（2）形参列表，因为方法可能重载
         *
         * 例如：void setName(String name)
         */
        Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);

        //3、创建实例对象
        Object stu = clazz.newInstance();

        //4、调用方法
        /*
         * 以前：学生对象.setName(值)
         * 现在：方法对象.invoke(学生对象，值)
         */
        Object setNameMethodReturnValue = setNameMethod.invoke(stu, "张三");

        System.out.println("stu = " + stu);
        //setName方法返回值类型void，没有返回值，所以setNameMethodReturnValue为null
        System.out.println("setNameMethodReturnValue = " + setNameMethodReturnValue);

        Method getNameMethod = clazz.getDeclaredMethod("getName");
        Object getNameMethodReturnValue = getNameMethod.invoke(stu);
        //getName方法返回值类型String，有返回值，getNameMethod.invoke的返回值就是getName方法的返回值
        System.out.println("getNameMethodReturnValue = " + getNameMethodReturnValue);//张三
    }
}

4.3.3 读取properties文件

读取user.properties文件中的数据，通过反射完成User类对象的创建及对应方法的调用。

配置文件：user.properties

className=com.suyv.reflect.User
name=张三
methodName=show

User.java文件：

package com.suyv.reflect;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 13:15
 * @Description: TODO
 */
public class User {
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
        "name='" + name + '\'' +
        '}';
    }

    public void show(){
        System.out.println("我是一个脉脉平台的用户");
    }
}

ReflectTest.java文件：

package com.suyv.reflect;

import org.junit.Test;

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

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-29 13:17
 * @Description: TODO
 */
public class ReflectTest {
    @Test
    public void test() throws Exception {
        //1.创建Properties对象
        Properties pro = new Properties();

        //2.加载配置文件，转换为一个集合
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        InputStream is = classLoader.getResourceAsStream("user.properties");
        pro.load(is);

        //3.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String n = pro.getProperty("name");
        String methodName = pro.getProperty("methodName");

        //4.加载该类进内存
        Class clazz = Class.forName(className);

        //5.创建对象
        Object instance = clazz.newInstance();

        //获取name
        Field field = clazz.getDeclaredField("name");
        field.setAccessible(true);

        field.set(instance,n);

        //6.获取方法对象
        Method showMethod = clazz.getMethod(methodName);

        //7.执行方法
        showMethod.invoke(instance);
    }
}