java学习笔记75：反射

参考

1. 简介

• 定义：Java语言中 一种 **动态（运行时）**访问、检测 & 修改它本身的能力
• 作用：动态（运行时）获取类的完整结构信息 & 调用对象的方法

1. 类的结构信息包括：变量、方法等
2. 正常情况下，Java类在编译前，就已经被加载到JVM中；而反射机制使得程序运行时还可以动态地去操作类的变量、方法等信息

1.1 优点

灵活性高。因为反射属于动态编译，即只有到运行时才动态创建 &获取对象实例。

编译方式说明：

1. 静态编译：在编译时确定类型 & 绑定对象。如常见的使用new关键字创建对象
2. 动态编译：运行时确定类型 & 绑定对象。动态编译体现了Java的灵活性、多态特性 & 降低类之间的藕合性

1.2 缺点

• 执行效率低
  因为反射的操作 主要通过JVM执行，所以时间成本会 高于 直接执行相同操作

1. 因为接口的通用性，Java的invoke方法是传object和object[]数组的。基本类型参数需要装箱和拆箱，产生大量额外的对象和内存开销，频繁促发GC。
2. 编译器难以对动态调用的代码提前做优化，比如方法内联。
3. 反射需要按名检索类和方法，有一定的时间开销。

• 容易破坏类结构
  因为反射操作饶过了源码，容易干扰类原有的内部逻辑

2、应用场景

• 动态获取 类文件结构信息（如变量、方法等） & 调用对象的方法
• 常用的需求场景有：动态代理、工厂模式优化、Java JDBC数据库操作等

3. 具体使用

3.1 Java反射机制提供的功能

3.2 实现手段

反射机制的实现 主要通过 操作java.lang.Class类

3.3 java.lang.Class 类

• 定义：java.lang.Class类是反射机制的基础
• 作用：存放着对应类型对象的 运行时信息

1. 在Java程序运行时，Java虚拟机为所有类型维护一个java.lang.Class对象
2. 该Class对象存放着所有关于该对象的 运行时信息
3. 泛型形式为Class<T>

• 每种类型的Class对象只有1个 = 地址只有1个

// 对于2个String类型对象，它们的Class对象相同
Class c1 = "Carson".getClass();
Class c2 =  Class.forName("java.lang.String");
// 用==运算符实现两个类对象地址的比较
System.out.println(c1 ==c2);  // 输出结果：true

3.4 Java反射机制的实现依靠的类

Java.lang.Class类（类对象）

java.lang.reflect.Constructor类（类的构造器对象）

java.lang.reflect.Field类（类的属性对象）

java.lang.reflectMethod类（类的方法对象）

4、使用步骤

在使用Java反射机制时，主要步骤包括：

1. 获取 目标类型的Class对象
2. 通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象
3. 通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法&属性的具体信息，并进行后续操作

步骤1：获取 目标类型的`Class`对象
步骤2：通过 `Class` 对象分别获取`Constructor`类对象、`Method`类对象 & `Field` 类对象
步骤3：通过 `Constructor`类对象、`Method`类对象 & `Field`类对象分别获取类的构造函数、方法 & 属性的具体信息 & 进行操作

4.1 获取目标类型的Class对象的4种方式

1、Object.getClass()

// Object类中的getClass()返回一个Class类型的实例 
Boolean carson = true; 
Class<?> classType = carson.getClass(); 
System.out.println(classType);
// 输出结果：class java.lang.Boolean  

2、T.class 语法

// T = 任意Java类型
Class<?> classType = Boolean.class; 
System.out.println(classType);
// 输出结果：class java.lang.Boolean  
// 注：Class对象表示的是一个类型，而这个类型未必一定是类
// 如，int不是类，但int.class是一个Class类型的对象

3、static method Class.forName

Class<?> classType = Class.forName("java.lang.Boolean"); 
// 使用时应提供异常处理器
System.out.println(classType);
// 输出结果：class java.lang.Boolean  

4、TYPE语法

Class<?> classType = Boolean.TYPE; 
System.out.println(classType);
// 输出结果：boolean  

4.2 java.lang.reflect.Type类

• java.lang.reflect.Type是 Java中所有类型的父接口
• 这些类型包括:

• 之间的关系如下
  

<–额外：java.lang.reflect.Modifier类 -->
// 作用：获取访问修饰符

5、 特别注意：访问权限问题

• 背景
  反射机制的默认行为受限于Java的访问控制

如，无法访问（ private ）私有的方法、字段

• 冲突
  Java安全机制只允许查看任意对象有哪些域，而不允许读它们的值

若强制读取，将抛出异常

• 解决方案
  脱离Java程序中安全管理器的控制、屏蔽Java语言的访问检查，从而脱离访问控制
• 具体实现手段：使用Field类、Method类 & Constructor类对象的setAccessible()

void setAccessible(boolean flag)	
// 作用：为反射对象设置可访问标志
// 规则：flag = true时 ，表示已屏蔽Java语言的访问检查，使得可以访问 & 修改对象的私有属性

boolean isAccessible()	
// 返回反射对象的可访问标志的值

static void setAccessible(AccessibleObject[] array, boolean flag)	
// 设置对象数组可访问标志
123456789

6、实例应用讲解

6.1 基础应用讲解

实例1：利用反射获取类的属性 & 赋值

<-- 测试类定义-->
public class Student {

    public Student() {
        System.out.println("创建了一个Student实例");
    }
    private String name;
}

<-- 利用反射获取属性 & 赋值 -->
        // 1. 获取Student类的Class对象
        Class studentClass = Student.class;

        // 2. 通过Class对象创建Student类的对象
        Object mStudent = studentClass.newInstance();
   
        // 3. 通过Class对象获取Student类的name属性
        Field f = studentClass.getDeclaredField("name");
        String name = (String)f.get(new Student());
 
        // 4. 设置私有访问权限
        f.setAccessible(true);

        // 5. 对新创建的Student对象设置name值
        f.set(mStudent, "Carson_Ho");

        // 6. 获取新创建Student对象的的name属性 & 输出
        System.out.println(f.get(mStudent));
123456789101112131415161718192021222324252627

• 测试结果

实例2：利用反射调用类的构造函数

<-- 测试类定义-->

public class Student {

    // 无参构造函数
    public Student() {
        System.out.println("调用了无参构造函数");
    }

    // 有参构造函数
    public Student(String str) {
        System.out.println("调用了有参构造函数");
    }

    private String name;
}

<-- 利用反射调用构造函数 -->
        // 1. 获取Student类的Class对象
        Class studentClass studentClass = Student.class;

        // 2.1 通过Class对象获取Constructor类对象，从而调用无参构造方法
        // 注：构造函数的调用实际上是在newInstance()，而不是在getConstructor()中调用
        Object mObj1 = studentClass.getConstructor().newInstance();
      
        // 2.2 通过Class对象获取Constructor类对象（传入参数类型），从而调用有参构造方法
        Object mObj2 = studentClass.getConstructor(String.class).newInstance("Carson");
        
1234567891011121314151617181920212223242526272829

• 测试结果

实例3：利用反射调用类对象的方法

<-- 测试类定义-->
public class Student {

    public Student() {
        System.out.println("创建了一个Student实例");
    }

    // 无参数方法
    public void setName1 (){
        System.out.println("调用了无参方法：setName1（）");
    }

    // 有参数方法
    public void setName2 (String str){
        System.out.println("调用了有参方法setName2（String str）:" + str);
    }
}

<-- 利用反射调用方法 -->
        // 1. 获取Student类的Class对象
        Class studentClass = Student.class;

        // 2. 通过Class对象创建Student类的对象
        Object  mStudent = studentClass.newInstance();

        // 3.1 通过Class对象获取方法setName1（）的Method对象:需传入方法名
        // 因为该方法 = 无参，所以不需要传入参数
        Method  msetName1 = studentClass.getMethod("setName1");

        // 通过Method对象调用setName1（）：需传入创建的实例
        msetName1.invoke(mStudent);

        // 3.2 通过Class对象获取方法setName2（）的Method对象:需传入方法名 & 参数类型
        Method msetName2 = studentClass.getMethod("setName2",String.class);

       // 通过Method对象调用setName2（）：需传入创建的实例 & 参数值
        msetName2.invoke(mStudent,"Carson_Ho");
    

123456789101112131415161718192021222324252627282930313233343536373839

• 测试结果