的反射（Reflection）是一种强大的机制，允许程序在运行时动态获取类的信息、操作类的成员（属性、方法、构造器），甚至修改类的行为。它是框架开发（如 Spring、MyBatis）、单元测试工具（如 JUnit）的核心技术之一。
一、认识反射
反射的核心是在运行时获取类的元数据（类的结构信息），突破了传统编程 “编译时确定类型” 的限制。例如：
运行时判断任意对象的所属类；
运行时构造任意类的对象；
运行时获取 / 修改类的属性、调用类的方法（包括私有成员）；
运行时处理注解。
二、Class 类详解
在 中，Class 类是反射的入口。每个类被加载到 JVM 时，会生成唯一的 Class 对象，存储该类的所有元数据（如类名、父类、接口、属性、方法等）。
2.1 获取 Class 对象的 3 种方式
// 方式1：通过 类名.class（编译时已知类）
Class<String> stringClass = String.class;
// 方式2：通过 对象.getClass()（已知对象）
String str = "hello";Class<? extends String> strClass = str.getClass();
// 方式3：通过 Class.forName("全限定类名")（动态加载，最常用）
try {
Class<?> userClass = Class.forName("com.example.User"); }
catch (ClassNotFoundException e) {
e.printStackTrace();
}
2.2 Class 类的常用方法
方法 |
说明 |
getName() |
获取类的全限定名（如 .lang.String） |
getSimpleName() |
获取类的简单名（如 String） |
getSuperclass() |
获取父类的 Class 对象 |
getInterfaces() |
获取实现的接口数组 |
getFields() |
获取所有公有属性（含父类） |
getDeclaredFields() |
获取所有属性（含私有，不含父类） |
getMethods() |
获取所有公有方法（含父类） |
getDeclaredMethods() |
获取所有方法（含私有，不含父类） |
getConstructors() |
获取所有公有构造器 |
getDeclaredConstructors() |
获取所有构造器（含私有） |
三、Class 类与多态
多态的本质是 “父类引用指向子类对象”，但反射可以突破多态的表象，直接操作子类或父类的真实信息。
示例：通过反射获取多态对象的真实类信息
假设有继承关系：Animal（父类）→ Dog（子类）。
class Animal {
public void eat() {
System.out.println("Animal eat");
}
}
class Dog extends Animal {
@Override
public void eat() {
System.out.println("Dog eat");
}
}
public class PolymorphismDemo {
public static void main(String[] args) {
Animal animal = new Dog(); // 多态：父类引用指向子类对象
// 传统方式调用方法（表现多态）
animal.eat(); // 输出：Dog eat
// 反射获取真实类的信息
Class<?> realClass = animal.getClass();
System.out.println("真实类名：" + realClass.getSimpleName()); // 输出：Dog
// 反射调用父类的方法（绕过多态）
try {
Method parentEat = realClass.getSuperclass().getMethod("eat");
parentEat.invoke(animal); // 输出：Animal eat（调用了父类的原始方法）
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果：
Dog eat
真实类名：Dog
Animal eat
四、反射创建类对象
通过反射可以动态创建类的实例，即使类的构造器是私有的（需设置 setAccessible(true)）。
4.1 无参构造创建对象
class User {
private String name;
public User() { System.out.println("无参构造被调用"); }
public User(String name) { this.name = name; }
}
public class CreateObjectDemo {
public static void main(String[] args) {
try {
// 1. 获取User的Class对象
Class<?> userClass = Class.forName("com.example.User");
// 2. 通过无参构造创建实例（等价于 new User()）
User user = (User) userClass.getDeclaredConstructor().newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出：无参构造被调用
4.2 有参构造创建对象
public class CreateObjectWithArgsDemo {
public static void main(String[] args) {
try {
Class<?> userClass = Class.forName("com.example.User");
// 获取有参构造器（参数类型为String）
Constructor<?> constructor = userClass.getDeclaredConstructor(String.class);
// 创建实例（等价于 new User("xxx")）
User user = (User) constructor.newInstance("xxx");
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.3 私有构造器创建对象（突破访问限制）
class SecretClass {
private SecretClass() { System.out.println("私有构造被调用");
}
}
public class CreatePrivateObjectDemo {
public static void main(String[] args) {
try {
Class<?> secretClass = Class.forName("com.example.SecretClass");
// 获取私有构造器
Constructor<?> privateConstructor = secretClass.getDeclaredConstructor();
// 允许访问私有成员（关键！）
privateConstructor.setAccessible(true);
// 创建实例
SecretClass instance = (SecretClass) privateConstructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出：私有构造被调用
五、反射调用类方法
通过反射可以调用任意对象的方法（包括私有方法），甚至可以调用未实现的方法（动态代理的基础）。
5.1 调用公有方法
class Calculator {
public int add(int a, int b) { return a + b; }
}
public class InvokeMethodDemo {
public static void main(String[] args) {
try {
Calculator calc = new Calculator();
Class<?> calcClass = calc.getClass();
// 获取add方法（参数类型为int, int）
Method addMethod = calcClass.getMethod("add", int.class, int.class);
// 调用方法（等价于 calc.add(3, 5)）
int result = (int) addMethod.invoke(calc, 3, 5);
System.out.println("计算结果：" + result); // 输出：8
} catch (Exception e) {
e.printStackTrace();
}
}
}
5.2 调用私有方法（突破访问限制）
class PrivateMethodClass {
private String formatName(String name) {
return "Hello, " + name + "!";
}
}
public class InvokePrivateMethodDemo {
public static void main(String[] args) {
try {
PrivateMethodClass obj = new PrivateMethodClass();
Class<?> clazz = obj.getClass();
// 获取私有方法（方法名、参数类型）
Method privateMethod = clazz.getDeclaredMethod("formatName", String.class);
// 允许访问私有成员
privateMethod.setAccessible(true);
// 调用方法（等价于 obj.formatName("xxx")）
String result = (String) privateMethod.invoke(obj, "xxx");
System.out.println(result); // 输出：Hello, xxx!
} catch (Exception e) {
e.printStackTrace();
}
}
}
六、反射修改类属性
通过反射可以直接修改对象的属性值（包括私有属性），甚至绕过 setter 方法。
6.1 修改公有属性
class Book {
public String title = "默认书名";
}
public class ModifyFieldDemo {
public static void main(String[] args) {
try {
Book book = new Book();
Class<?> bookClass = book.getClass();
// 获取公有属性title
Field titleField = bookClass.getField("title");
// 修改属性值（等价于 book.title = "反射详解"）
titleField.set(book, "反射详解");
System.out.println(book.title); // 输出：反射详解
} catch (Exception e) {
e.printStackTrace();
}
}
}
6.2 修改私有属性（突破访问限制）
class User {
private String password = "123456";}
public class ModifyPrivateFieldDemo {
public static void main(String[] args) {
try {
User user = new User();
Class<?> userClass = user.getClass();
// 获取私有属性password
Field passwordField = userClass.getDeclaredField("password");
// 允许访问私有成员
passwordField.setAccessible(true);
// 修改属性值（等价于 user.password = "new_password"）
passwordField.set(user, "new_password");
// 验证修改结果
System.out.println("新密码：" + passwordField.get(user)); // 输出：new_password
} catch (Exception e) {
e.printStackTrace();
}
}
}
七、类加载器
类加载器（Class Loader）负责将 .class 文件加载到 JVM 中，生成对应的 Class 对象。 采用双亲委派模型，确保类的唯一性和安全性。
7.1 类加载器的层级
引导类加载器（Bootstrap Class Loader）：加载 JDK 核心类（如 .lang.*），由 C++ 实现，无法通过 代码获取。
扩展类加载器（Extension Class Loader）：加载 jre/lib/ext 目录下的 JAR 包。
应用类加载器（Application Class Loader）：加载用户项目中的类（classpath 下的类）。
7.2 示例：查看类的加载器
public class ClassLoaderDemo {
public static void main(String[] args) {
// 获取String类的加载器（引导类加载器，输出null）
ClassLoader stringLoader = String.class.getClassLoader();
System.out.println("String类的加载器：" + stringLoader); // 输出：null
// 获取当前类的加载器（应用类加载器）
ClassLoader selfLoader = ClassLoaderDemo.class.getClassLoader();
System.out.println("当前类的加载器：" + selfLoader);
// 输出：sun.misc.Launcher$AppClassLoader@18b4aac2
// 获取应用类加载器的父加载器（扩展类加载器）
ClassLoader parentLoader = selfLoader.getParent();
System.out.println("父加载器：" + parentLoader);
// 输出：sun.misc.Launcher$ExtClassLoader@1b6d3586
}
}
7.3 双亲委派模型的作用
当加载一个类时，类加载器会先委托父类加载器尝试加载，直到引导类加载器。如果父类无法加载，才由当前类加载器加载。
好处：避免重复加载，防止核心类被篡改（如自定义 .lang.String 不会被加载）。
反射是 的 “动态之魂”，但过度使用会降低代码可读性和安全性（如破坏封装性）。实际开发中，框架（如 Spring）已封装了反射的复杂操作，开发者只需理解原理即可。建议结合源码（如 Spring 的 BeanFactory）深入学习反射的应用。