反射

一、一个需求引出反射

1.1 看一个问题

1. 根据配置文件 re.properties 指定信息，创建 Cat对象实例并调用方法 hi
   classfullpath=com.hspedu.Cat
   method=hi

思考：使用现有技术，能实现吗？

1. 这样的需求在学习框架时特别多，即通过外部文件配置，在不修改源码的情况下，来控制程序，也符合设计模式的 ocp 原则（开闭原则：不修改源码，扩容功能）

1.2 快速演示

package com.hspedu.reflection.question;
import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
 * @author HarborGao
 * @version 1.0
 * 反射问题的引入
 */
@SuppressWarnings({"all"})
public class ReflectionQuestion {
    public static void main(String[] args) throws Exception {
        //传统创建对象实例，并调用方法
        //Cat cat = new Cat();
        //cat.hi();
        /**
          根据配置文件 re.properties 指定信息，创建 Cat对象实例并调用方法 hi
         */
        //用传统方案解决
        //1. 先读入配置文件
        FileInputStream fileInputStream = new FileInputStream("src\\re.properties");
        Properties properties = new Properties();
        properties.load(fileInputStream);
        String classfullpath = properties.getProperty("classfullpath");
        String methodName = properties.getProperty("method");
        //2. 尝试创建实例并调用方法
        //classfullpath obj = new classfullpath();  //非法的创建实例方式
        //obj.methodName();  //非法的方法调用方式
        //可发现，传统方法可以取出文件里的信息（String类型），但是无法根据信息创建Cat实例并调用方法
        //因此引入反射机制 reflect
        //使用反射解决上述问题 案例演示
        //1. 加载类，返回Class类型的对象实例 cls
        Class cls = Class.forName(classfullpath);
        //2. 通过 cls 得到加载的类 com.hspedu.Cat 的对象实例
        Object o = cls.newInstance();
        System.out.println("o 的运行类型=" + o.getClass());
        //3. 通过 cls 得到加载的类 com.hspedu.Cat 的 methodName "hi" 的方法对象
        //说明: 在反射中，可以把对象也视为对象（万物皆对象）
        Method method = cls.getMethod(methodName);
        //4. 通过 method 调用方法：即通过方法对象来实现调用方法
        System.out.println("===================");
        method.invoke(o);  //传统方法 对象.方法(), 反射机制 方法.invoke(对象)
    }
}

二、反射机制

2.1 Java Reflection

1. 反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
2. 加载完类之后，在堆中就产生了一个 Class 类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子可以看到类的结构，所以，形象地称之为 反射。

2.2 Java 反射机制原理示意图

2.3 Java 反射机制的用途

1. 在运行时判断任意一个对象所属的类
2. 在运行时构造任意一个类的对象
3. 在运行时得到任意一个类所具有的成员变量和方法
4. 在运行时调用任意一个对象的成员变量和方法
5. 生成动态代理

2.4 反射相关的主要类

1. java.lang.Class：代表一个类，Class 对象表示某个类加载后在堆中的对象
2. java.lang.reflect.Method：代表类的方法，Method 对象表示某个类的方法
3. java.lang.reflect.Field：代表类的成员变量，Field 对象表示某个类的成员变量
4. java.lang.reflect.Constructor：代表类的构造方法，Constructor对象表示构造器

这些类在 java.lang.reflection

案例演示

package com.hspedu.reflection;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;
/**
 * @author HarborGao
 * @version 1.0
 * 反射相关主要类的使用
 */
@SuppressWarnings({"all"})
public class Reflect01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("src\\re.properties");
        Properties properties = new Properties();
        properties.load(fileInputStream);
        String classfullpath = properties.getProperty("classfullpath");
        String methodName = properties.getProperty("method");
        //1. 加载类，返回Class类型的对象实例 cls
        Class cls = Class.forName(classfullpath);
        //2. 通过 cls 得到加载的类 com.hspedu.Cat 的对象实例
        Object o = cls.newInstance();
        System.out.println("o 的运行类型=" + o.getClass());
        //3. 通过 cls 得到加载的类 com.hspedu.Cat 的 methodName "hi" 的方法对象
        //说明: 在反射中，可以把对象也视为对象（万物皆对象）
        Method method = cls.getMethod(methodName);
        //4. 通过 method 调用方法：即通过方法对象来实现调用方法
        System.out.println("===================");
        method.invoke(o);  //传统方法 对象.方法(), 反射机制 方法.invoke(对象)
        // java.lang.reflect.Field：代表类的成员变量，Field 对象表示某个类的成员变量
        // 得到 name 字段
        // getField 不能得到私有的属性
        Field nameField = cls.getField("name");
        System.out.println(nameField.get(o));  //传统写法 对象.成员变量  反射 成员变量对象.get(对象)
        // java.lang.reflect.Constructor：代表类的构造方法，Constructor对象表示构造器
        Constructor constructor = cls.getConstructor();  //返回无参构造器
        System.out.println(constructor);  //相当于 Cat()
        Constructor constructor2 = cls.getConstructor(String.class);  //返回指定形参构造器
        //说明：传入的 String.class 就是 String类 的 Class对象
        System.out.println(constructor2);  //Cat(String name)
    }
}

2.5 反射优点和缺点

1. 优点：可以动态的创建和使用对象（也是框架底层的核心），使用灵活，没有反射机制，框架技术就失去底层支撑。
2. 缺点：使用反射基本是解释执行，对执行速度有影响。

案例演示

package com.hspedu.reflection;
import com.hspedu.Cat;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * @author HarborGao
 * @version 1.0
 * 测试反射调用的性能
 */
public class Reflection02 {
    public static void main(String[] args) throws Exception{
        m1();
        m2();
        m3();
    }
    //传统方式调用方法
    public static void m1() {
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999999; i++) {
            cat.count();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1() 耗时 " + (end - start));
    }
    //使用反射调用方法
    public static void m2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.hspedu.Cat");
        Cat cat = (Cat) cls.newInstance();
        Method method = cls.getMethod("count");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999999; i++) {
            method.invoke(cat);
        }
        long end = System.currentTimeMillis();
        System.out.println("m2() 耗时 " + (end - start));
    }
    //反射优化 + 关闭访问安全检查
    public static void m3() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.hspedu.Cat");
        Cat cat = (Cat) cls.newInstance();
        Method method = cls.getMethod("count");
        method.setAccessible(true); //在反射调用方法时，取消访问检查
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999999; i++) {
            method.invoke(cat);
        }
        long end = System.currentTimeMillis();
        System.out.println("m3() 耗时 " + (end - start));
    }
}

2.6 反射调用优化 - 关闭访问检查

1. Method 和 Method、Constructor 对象都有 setAccessible() 方法
2. setAccessible() 方法 的作用是启动和禁用访问安全检查的开关
3. 参数值为 true 表示 反射的对象在使用时取消访问检查，提高反射的效率。参数值为 false 则表示反射的对象执行访问检查

三、Class 类

3.1 基本介绍

1. Class 也是类，因此也继承 Object类
2. Class 类对象不是 new 出口的，而是系统创建的
3. 对于某个类的 Class类对象，在内存中只有一份，因为类只加载一次
4. 每个类的实例都会记得自己是由哪个 Class 实例所生成
5. 通过 Class 对象可以完整地得到一个类的完整结构，通过一系列 API
6. Class 对象是存放在堆中的
7. 类的字节码二进制数据，是放在方法区的，有的地方成为类的元数据（包括 方法代码，变量名，方法名，访问权限等等）

package com.hspedu.reflection.class_;
import com.hspedu.Cat;
import java.util.ArrayList;
/**
 * @author HarborGao
 * @version 1.0
 * 对 Class 类特点的梳理
 */
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //看看 Class 类图
        //1. Class 也是类，因此也继承 Object 类
        //Class
        //2. Class 类对象不是 new 出来的，而是系统创建的
        //(1) 传统 new 对象
        /* ClassLoader 类
        public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
        }
        */
        //Cat cat = new Cat();
        //(2) 反射方式, 刚才老师没有 debug 到 ClassLoader 类的 loadClass, 原因是，我没有注销 Cat cat = new Cat();
        /*
            ClassLoader 类, 仍然是通过 ClassLoader 类加载 Cat 类的 Class 对象
            public Class<?> loadClass(String name) throws ClassNotFoundException {
            return loadClass(name, false);
            }
        */
        Class cls1 = Class.forName("com.hspedu.Cat");
        //3. 对于某个类的 Class 类对象，在内存中只有一份，因为类只加载一次
        Class cls2 = Class.forName("com.hspedu.Cat");
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        Class cls3 = Class.forName("com.hspedu.Dog");
        System.out.println(cls3.hashCode());
    }
}

3.2 Class 类的常用方法

3.3 应用实例

package com.hspedu.reflection.class_;
import com.hspedu.Car;
import java.lang.reflect.Field;
/**
 * @author HarborGao
 * @version 1.0
 * 演示 Class类的常用方法
 */
public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String classAllPath = "com.hspedu.Car";
        //1. 获取到 Car类 对应的 Class对象
        //说明: <?> 表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls);  //显示 cls对象，是哪个类的Class对象 com.hspedu.Car
        System.out.println(cls.getClass());  //输出 cls运行类型 java.lang.Class
        //3. 得到包名
        System.out.println(cls.getPackage().getName());
        //4. 得到全类名
        System.out.println(cls.getName());
        //5. 通过 cls 创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);  //car.toString
        //6. 通过反射获取属性 brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));
        //7. 通过反射给属性赋值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car));
        //8. 得到所有的属性(字段)
        System.out.println("=======所有的字段属性========");
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
    }
}

3.4 获取 Class 类对象

1. 前提：已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法 forName() 获取，可能抛出 ClassNotFoundException。实例：Class cls1 = Class.forName(“com.hspedu.Cat”);
   应用场景：多用于配置文件，读取类全路径，加载类

2. 前提：若已知具体的类，通过类的 class 获取，该方式最为安全可靠，程序性能最高。实例：Class cls2 = Cat.class;
   应用场景：多用于参数传递，比如通过反射得到对应构造器对象

3. 前提：已知某个类的实例，调用该实例的 getClass() 方法获取 Class对象。实例：Class cls3 = 对象.getClass()
   应用场景：通过创建好的对象，获取 Class对象

4. 其他方式
   ClassLoader cl = 对象.getClass().getClassLoader();
   Class cls4 = cl.loadClass(“类的全类名”);

5. 基本数据（int，char，boolean，float，double，byte，long，short）按如下方式得到 Class类对象
   Class cls = 基本数据类型.class

6. 基本数据类型对应的包装类，可以通过 .TYPE 得到 Class类对象

package com.hspedu.reflection.class_;
import com.hspedu.Car;
/**
 * @author HarborGao
 * @version 1.0
 * 演示得到 Class对象的各种方式(6)
 */
public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1. Class.forName
        String classAllPath = "com.hspedu.Car";  //通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);
        //2. 类名.class  应用场景：用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);
        //3. 对象.getClass()  应用场景：有实例对象
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);
        //4. 通过类加载器{4种} 来获取到类的 Class对象
        //(1) 先得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2) 通过类加载器得到Class 对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);
        //cls1,cls2,cls3,cls4 其实是同一个对象
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());
        //5. 基本数据（int，char，boolean，float，double，byte，long，short）按如下方式得到 Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        Class<Float> floatClass = float.class;
        Class<Double> doubleClass = double.class;
        Class<Byte> byteClass = byte.class;
        Class<Long> longClass = long.class;
        Class<Short> shortClass = short.class;
        System.out.println(integerClass);  //int
        //6. 基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1);
        System.out.println(integerClass.hashCode());//?
        System.out.println(type1.hashCode());//?
    }
}

3.5 有 Class对象的类型

1. 外部类，成员内部类，静态内部类，局部内部类，匿名内部类
2. interface：接口
3. 数组
4. enum：枚举
5. annotation：注解
6. 基本数据类型
7. void

应用案例

package com.hspedu.reflection.class_;
import java.io.Serializable;
/**
 * @author HarborGao
 * @version 1.0
 * 演示哪些类型有 Class对象
 */
public class AllTypeClass {
    public static void main(String[] args) {
        Class<String> cls1 = String.class;  //外部类
        Class<Serializable> cls2 = Serializable.class;  //接口
        Class<Integer[]> cls3 = Integer[].class;  //数组
        Class<float[][]> cls4 = float[][].class;  //二维数组
        Class<Deprecated> cls5 = Deprecated.class;  //注解
        Class<Thread.State> cls6 = Thread.State.class;  //枚举
        Class<Long> cls7 = long.class;  //基本数据类型
        Class<Void> cls8 = void.class;  //void数据类型
        Class<Class> cls9 = Class.class;
        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls4);
        System.out.println(cls5);
        System.out.println(cls6);
        System.out.println(cls7);
        System.out.println(cls8);
        System.out.println(cls9);
    }
}

四、类加载

4.1 基本说明

反射语言是 java 实现动态语言的关键，也就是通过反射实现类动态加载。

1. 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
2. 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，也不会报错，降低了依赖性

4.2 类加载时机

1. 当创建对象时（new） //静态加载
2. 当子类被加载时，父类也加载 //静态加载
3. 通过类中的静态成员时 //静态加载
4. 通过反射 //动态加载

4.3 类加载过程图

4.4 类加载各阶段完成任务

4.5 加载阶段 Loading

JVM 在该阶段的主要目的是将字节码从不同的数据源（可能是 class 文件、也可能是 jar包，甚至网络）转换为二进制字节流加载到内存中，并生成一个代表该类的 java.lang.Class 对象

4.6 连接阶段 - 验证 Verification

1. 目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
2. 包括：文件格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证
3. 可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间

4.7 连接阶段 - 准备 Preparation

1. JVM 会在该阶段对静态变量，分配内存并初始化（对应数据类型的默认初始化，如0、0L、null、false等）。这些变量所使用的内存都将在方法区中进行分配
2. 举例说明 ```java package com.hspedu.reflection.classload_;

/**

• @author HarborGao
• @version 1.0

• 说明类加载 连接阶段 - 准备 */ public class ClassLoad01 { public static void main(String[] args) {

  } } class A { //属性 - 成员变量 - 字段 //分析类加载的连接阶段-准备 字段是如何处理 //1. n1 是实例属性，不是静态变量，因此在准备阶段，是不会分配内存 //2. n2 是静态变量，分配内存 n2 是默认初始化 0，而不是20 //3. n3 是 static final 是常量，和静态变量不一样，因为一旦赋值就不变 n3 = 30 public int n1 = 10; public static int n2 = 20; public static final int n3 = 30;

}

<a name="hXcW3"></a>
#### 4.8  连接阶段 - 解析 Resolution
虚拟机将常量池内的符号引用(字面上的引用)替换为直接引用(地址引用)的过程
<a name="hXk6u"></a>
#### 4.9  类加载 Initialization（初始化）
1. 到初始化阶段，才真正开始执行类中定义的 Java程序代码，此阶段是执行 <clinit>() 方法的过程
1. <clinit>() 方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并
1. 虚拟机会保证一个类的 <clinit>() 方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 <clinit>() 方法，其他线程都需要阻塞等待，直到活动线程执行 <clinit>() 方法完毕
```java
package com.hspedu.reflection.classload_;
/**
 * @author HarborGao
 * @version 1.0
 * 演示类加载 - 初始化阶段
 */
public class ClassLoad02 {
    public static void main(String[] args) {
        //类加载过程分析：
        //1. 加载B类，并生成B 类的 Class对象
        //2. 连接阶段 num = 0
        //3. 初始化阶段
        //     依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并
        /*
            clinit() {
                System.out.println("B的静态代码块被执行");
                num = 300;
                num = 100;
            }
            合并: num = 100
         */
        //new B();  //如果不实例化对象，构造器就不会调用，构造器是在构造实例化对象的时候工作
        System.out.println(B.num); //如果直接使用类的静态属性，也会导致类的加载
    }
}
class B {
    static {
        System.out.println("B的静态代码块被执行");
        num = 300;
    }
    static int num = 100;
    public B() {
        System.out.println("B的构造器被执行");
    }
}

五、通过反射获取类的结构信息

5.1 第一组：java.lang.Class 类

package com.hspedu.reflection;
import org.junit.jupiter.api.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * @author HarborGao
 * @version 1.0
 */
public class ReflectionUtils {
    public static void main(String[] args) {
    }
    @Test
    public void api_01() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getName    获取全类名
        System.out.println(personCls.getName());
        //getSimpleName    获取简单类名
        System.out.println(personCls.getSimpleName());
        //getFields    获取所有public 修饰的属性，包含本类及父类
        Field[] fields = personCls.getFields();
        for (Field field : fields) {
            System.out.println("本类及父类的public属性=" + field.getName());
        }
        //getDeclaredFields    获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类的所有属性=" + declaredField.getName());
        }
        //getMethods    获取所有 public 修饰的方法，包括本类及父类
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println("本类及父类的public方法=" + method.getName());
        }
        //getDeclaredMethods    获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有方法=" + declaredMethod.getName());
        }
        //getConstructors    获取所有 public 修饰的构造器
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类的public 构造器 = " + constructor.getName());
        }
        //getDeclaredConstructors    获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类所有的构造器 = " + declaredConstructor.getName());
        }
        //getPackage    以 Package 形式返回包信息
        System.out.println(personCls.getPackage());
        //getSuperClass    以 Class 形式返回父类信息
        Class<?> superclass = personCls.getSuperclass();
        System.out.println("父类=" + superclass);
        //getInterfaces    以 CLass[] 形式返回接口信息
        Class<?>[] interfaces = personCls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息=" + anInterface);
        }
        //getAnnotations    以 Annotation[] 形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息=" + annotation);
        }
    }
}
class A {
    public String hobby;
    public void hi() {}
    public A() {}
}
interface IA{
}
interface IB{
}
@Deprecated
class Person extends A implements IA,IB{
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;
    public Person() {}
    public Person(String name) {
        this.name = name;
    }
    private Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //方法
    public void m1() {
    }
    protected void m2() {
    }
    void m3() {
    }
    private void m4() {
    }
}

5.2 第二组：java.lang.reflect.Field 类

//第二组方法API
    @Test
    public void api_02() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getDeclaredFields    获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        //getModifiers    以 int 形式返回修饰符
        //说明：默认修饰符是 0，public 是1，private 是2，protected 是4，static 是 8，final 是 16
        for (Field declaredField : declaredFields) {
            System.out.println("本类的所有属性=" + declaredField.getName()
            + "该属性的修饰符值=" + declaredField.getModifiers()
            + "该属性的类型=" + declaredField.getType());
        }
    }

5.3 第三组：java.lang.reflect.Method 类

//第三组方法API
    @Test
    public void api_03() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getDeclaredMethods    获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有方法=" + declaredMethod.getName()
            + "该方法的修饰符值= " + declaredMethod.getModifiers()
            + "获取该方法的返回类型=" + declaredMethod.getReturnType());
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该方法的形参类型 = " + parameterType);
            }
        }
    }

5.4 第四组：java.lang.reflect.Constructor 类

//第四组方法API
    @Test
    public void api_04() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getDeclaredConstructors    获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类所有的构造器 = " + declaredConstructor.getName()
            + " 构造器的修饰值=" + declaredConstructor.getModifiers());
            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("构造器的形参类型 = " + parameterType);
            }
        }
    }

六、通过反射创建对象

6.1 方式介绍

1. 方式一：调用类中的 public 修饰的无参构造器

2. 方式二：调用类中的指定构造器

3. Class 类相关方法

   1. new Instance：调用类中的无参构造器，获取对应类的对象
   2. getConstructor(Class…clazz)：根据参数列表，获取对应public 的构造器对象
   3. getDeclaredConstructor(Class…clazz)：根据参数列表，获取对应的构造器对象

4. Constructor 类相关方法

   1. setAccessible：暴破
   2. new Instance(Object…obj)：调用构造器

6.2 案例演示

1. 测试1：通过反射创建某类的对象，要求该类中必须有 public 的无参构造
2. 测试2：通过调用某个特定构造器的方式，实现创建某类的对象

package com.hspedu.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
 * @author HarborGao
 * @version 1.0
 * 演示通过反射机制创建实例
 */
public class ReflectCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1. 先获取到 User类的 Class对象
        Class<?> cls = Class.forName("com.hspedu.reflection.User");
        //2. 通过 public 的无参构造器创建实例
        Object o = cls.newInstance();
        System.out.println(o);
        //3. 通过 public 的有参构造器创建实例
        Constructor<?> constructor = cls.getConstructor(String.class);
        Object tom = constructor.newInstance("Tom");
        System.out.println(tom);
        //4. 通过 private 的有参构造器创建实例
        Constructor<?> constructor1 = cls.getDeclaredConstructor(int.class,String.class);
        constructor1.setAccessible(true); //暴破【暴力破解】，使用反射可以访问私有的 private构造器/方法/属性
        Object king = constructor1.newInstance(12, "king");  //因为是该构造器是私有的，只允许在类中引用，所以需要暴破
        System.out.println(king);
    }
}
class User{
    private int age = 10;
    private String name = "jack";
    public User() {}
    public User(String name) {
        this.name = name;
    }
    private User(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

七、通过反射访问类中的成员

7.1 访问属性

1. 根据属性名获取 Field 对象

Field f = clazz对象.getDeclaredField(属性名);

1. 暴破：f.setAccessible(true); //f 是 Field类型

2. 访问
   f.set(o,值);
   syso(f.get(o));

3. 如果是静态属性，则 set 和 get 中的参数 o，可以写成 null

7.2 访问属性案例演示

package com.hspedu.reflection;
import java.lang.reflect.Field;
/**
 * @author HarborGao
 * @version 1.0
 * 演示反射操作属性
 */
public class ReflectAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        //1. 得到 Student类对应的 Class对象
        Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();  //o的运行类型就是 Student
        //3. 使用反射得到 age 属性对象
        Field age = stuClass.getField("age");
        age.set(o,88);  //通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));  //直接得到age属性的值
        //4. 使用反射操作 name 属性
        Field name = stuClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"jack");
        System.out.println(o);
        System.out.println(name.get(o));
        System.out.println(name.get(null));  //因为 name 是 static 属性，因此 o 也可以写成 null
    }
}
class Student {
    public int age;
    private static String name;
    public Student() {}
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age + ",name=" + name +
                '}';
    }
}

7.3 访问方法

1. 根据方法名和参数列表获取 Method方法对象：Method m = clazz.getDeclaredMethod(方法名, XX.class);

2. 获取对象：Object o = clazz.newInstance();

3. 暴破：m.setAccessible(true);

4. 访问：Object returnValue = m.invoke(o, 实参列表);

5. 注意：如果是静态方法，则 invoke的参数 o，可以写成 null

7.4 访问方法案例演示

package com.hspedu.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * @author HarborGao
 * @version 1.0
 * 演示通过反射调用方法
 */
public class ReflectAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1. 得到 Boss 类对应的 Class 对象
        Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用 public 的 hi() 方法
        Method hi = bossCls.getMethod("hi", String.class);
        //Method hi = bossCls.getDeclaredMethod("hi", String.class);  //得到 hi方法对象
        hi.invoke(o,"java");  //调用
        //4. 调用 private 的 say() 方法
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);
        //说明：在反射中，如果方法有返回值，统一返回Object，运行类型保持原来不变
        Object invoke = say.invoke(null, 16, "some", 's');
        System.out.println(invoke);
    }
}
class Boss{
    public int age;
    private static String name;
    public Boss() {
    }
    private static String say(int n, String s, char c) {
        return n + " " + s + " " + c;
    }
    public void hi(String s) {
        System.out.println("hi! " + s);
    }
}

八、本章作业

1. 编程题
   通过反射修改私有成员变量
   1. 定义PrivateTest类, 有私有name属性，并且属性值为hellokitty
   2. 提供getName的公有方法
   3. 创建PrivateTest的类， 利用Class类得到私有的name属性， 修改私有的name属性值，并调用getName()的方法打印name属性值

package com.hspedu.homework;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * @author HarborGao
 * @version 1.0
 */
public class Homework01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class<?> cls = Class.forName("com.hspedu.homework.PrivateTest");
        Object o = cls.newInstance();
        Field name = cls.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"Tom");
        Method getName = cls.getMethod("getName");
        Object invoke = getName.invoke(o);
        System.out.println(invoke);
    }
}
class PrivateTest {
    private String name = "hellokitty";
    public String getName() {
        return name;
    }
}

1. 编程题

利用反射和File完成以下功能

1. 利用Class类的forName方法得到File类的class对象
2. 在控制台打印File类的所有构造器
3. 通过newInstance的方法创建File对象， 并创建 E:\mynew.txt 文件

提示：创建文件的正常写法如下:
File file = new File(“ d:\aa.txt”);//内存
file.createNewFile();//方法，才能真正的创建文件

package com.hspedu.homework;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * @author HarborGao
 * @version 1.0
 */
public class Homework02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class<?> fileCls = Class.forName("java.io.File");
        Constructor<?>[] declaredConstructors = fileCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor.getName());
            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("构造器参数 " + parameterType);
            }
        }
        String filePath = "E:\\mynew.txt";
        Object o = fileCls.getConstructor(String.class).newInstance(filePath);
        Method createNewFile = fileCls.getDeclaredMethod("createNewFile");
        createNewFile.invoke(o);
    }
}

学习参考（致谢）：

1. B站 @程序员鱼皮 Java学习一条龙
2. B站 @韩顺平 零基础30天学会Java