Java 反射（Reflection）
Java 反射（Reflection）是一个强大的特性，它允许程序在运行时查询、访问和修改类、接口、字段和方法的信息。反射提供了一种动态地操作类的能力，这在很多框架和库中被广泛使用，例如Spring框架的依赖注入。
反射 API
Java 的反射 API 提供了一系列的类和接口来操作 Class 对象。主要的类包括：
java.lang.Class：表示类的对象。提供了方法来获取类的字段、方法、构造函数等。java.lang.reflect.Field：表示类的字段（属性）。提供了访问和修改字段的能力。java.lang.reflect.Method：表示类的方法。提供了调用方法的能力。java.lang.reflect.Constructor：表示类的构造函数。提供了创建对象的能力。
工作流程
- 获取
Class对象：首先获取目标类的Class对象。 - 获取成员信息：通过
Class对象，可以获取类的字段、方法、构造函数等信息。 - 操作成员：通过反射 API 可以读取和修改字段的值、调用方法以及创建对象。
以下是 Java 反射的基本使用方式及其常见应用。
1. 获取 Class 对象
每个类在 JVM 中都有一个与之相关的 Class 对象。可以通过以下方式获取 Class 对象：
通过类字面量
Class<?> clazz = String.class;
通过对象实例：
String str = "Hello";
Class<?> clazz = str.getClass();
通过 Class.forName() 方法：
Class<?> clazz = Class.forName("java.lang.String");
2. 创建对象
可以使用反射动态创建对象：
Class<?> clazz = Class.forName("java.lang.String");
Object obj = clazz.getDeclaredConstructor().newInstance();
3. 访问字段
可以通过反射访问和修改类的字段：
Class<?> clazz = Person.class;
Field field = clazz.getDeclaredField("name");
field.setAccessible(true); // 如果字段是私有的，需要设置为可访问
Object value = field.get(personInstance); // 获取字段值
field.set(personInstance, "New Name"); // 设置字段值
4. 调用方法
可以通过反射调用类的方法：
Class<?> clazz = Person.class;
Method method = clazz.getMethod("sayHello");
method.invoke(personInstance);
Method methodWithArgs = clazz.getMethod("greet", String.class);
methodWithArgs.invoke(personInstance, "World");
5. 获取构造函数
可以使用反射获取和调用构造函数：
Class<?> clazz = Person.class;
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
Object obj = constructor.newInstance("John", 30);
6. 获取接口和父类
可以使用反射获取类实现的接口和父类：
Class<?> clazz = Person.class;
// 获取所有接口
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> i : interfaces) {
System.out.println("Interface: " + i.getName());
}
// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println("Superclass: " + superClass.getName());
以下是一个完整的示例，展示了如何使用反射来创建对象、访问字段和调用方法：
实例
**import** java.lang.reflect.Constructor;
**import** java.lang.reflect.Field;
**import** java.lang.reflect.Method;
**public** **class** ReflectionExample {
**public** **static** **void** main(String[] args) **throws** Exception {
*// 获取 Class 对象*
Class<?> clazz = Person.**class**;
*// 创建对象*
Constructor<?> constructor = clazz.getConstructor(String.**class**, **int**.**class**);
Object person = constructor.newInstance("John", 30);
*// 访问字段*
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(**true**);
System.out.println("Name: " + nameField.get(person));
*// 修改字段*
nameField.set(person, "Doe");
System.out.println("Updated Name: " + nameField.get(person));
*// 调用方法*
Method greetMethod = clazz.getMethod("greet", String.**class**);
greetMethod.invoke(person, "World");
}
}
**class** Person {
**private** String name;
**private** **int** age;
**public** Person(String name, **int** age) {
**this**.name = name;
**this**.age = age;
}
**public** **void** greet(String message) {
System.out.println(name + " says: " + message);
}
}
编译执行以上代码，输出结果为：
Name: John
Updated Name: Doe
Doe says: World
java.lang.reflect
java.lang.reflect 是 Java 反射机制的核心包，提供了操作类及其成员（字段、方法、构造函数等）的类和接口。通过这些 API，开发者可以在运行时动态地查询和修改类的结构。
以下是 java.lang.reflect 包中的主要类和接口的详细介绍：
1. Class 类
-
功能：表示类的对象，提供了获取类信息的方法，如字段、方法、构造函数等。
-
主要方法
：
getFields()：获取所有公共字段。getDeclaredFields()：获取所有声明的字段，包括私有字段。getMethods()：获取所有公共方法。getDeclaredMethods()：获取所有声明的方法，包括私有方法。getConstructors()：获取所有公共构造函数。getDeclaredConstructors()：获取所有声明的构造函数，包括私有构造函数。getSuperclass()：获取类的父类。getInterfaces()：获取类实现的所有接口。
2. Field 类
-
功能：表示类的字段（属性），提供了访问和修改字段值的方法。
-
主要方法
：
get(Object obj)：获取指定对象的字段值。set(Object obj, Object value)：设置指定对象的字段值。getType()：获取字段的数据类型。getModifiers()：获取字段的修饰符（如 public、private）。
3. Method 类
-
功能：表示类的方法，提供了调用方法的能力。
-
主要方法
：
invoke(Object obj, Object... args)：调用指定对象的方法。getReturnType()：获取方法的返回类型。getParameterTypes()：获取方法的参数类型。getModifiers()：获取方法的修饰符（如 public、private）。
4. Constructor 类
-
功能：表示类的构造函数，提供了创建对象的能力。
-
主要方法
：
newInstance(Object... initargs)：创建一个新实例，使用指定的构造函数参数。getParameterTypes()：获取构造函数的参数类型。getModifiers()：获取构造函数的修饰符（如 public、private）。
示例代码
以下是使用 java.lang.reflect 包进行反射操作的示例：
实例
**import** java.lang.reflect.Field;
**import** java.lang.reflect.Method;
**import** java.lang.reflect.Constructor;
**public** **class** ReflectionExample {
**public** **static** **void** main(String[] args) **throws** Exception {
*// 获取 Class 对象*
Class<?> clazz = Car.**class**;
*// 创建 Car 对象*
Constructor<?> constructor = clazz.getConstructor(String.**class**, **int**.**class**);
Object car = constructor.newInstance("Toyota", 2020);
*// 访问和修改字段*
Field modelField = clazz.getDeclaredField("model");
Field yearField = clazz.getDeclaredField("year");
*// 设置字段为可访问（如果字段是私有的）*
modelField.setAccessible(**true**);
yearField.setAccessible(**true**);
*// 打印原始字段值*
System.out.println("Original Model: " + modelField.get(car));
System.out.println("Original Year: " + yearField.get(car));
*// 修改字段值*
modelField.set(car, "Honda");
yearField.set(car, 2024);
*// 打印修改后的字段值*
System.out.println("Updated Model: " + modelField.get(car));
System.out.println("Updated Year: " + yearField.get(car));
*// 调用方法*
Method startMethod = clazz.getMethod("start");
startMethod.invoke(car);
}
}
**class** Car {
**private** String model;
**private** **int** year;
**public** Car(String model, **int** year) {
**this**.model = model;
**this**.year = year;
}
**public** **void** start() {
System.out.println("The " + model + " car of year " + year + " is starting.");
}
}
编译执行以上代码，输出结果为：
Original Model: Toyota
Original Year: 2020
Updated Model: Honda
Updated Year: 2024
The Honda car of year 2024 is starting.
r;
}
**public** **void** start() {
System.out.println("The " + model + " car of year " + year + " is starting.");
}
}
编译执行以上代码，输出结果为：
Original Model: Toyota
Original Year: 2020
Updated Model: Honda
Updated Year: 2024
The Honda car of year 2024 is starting.
