目录
一. 简介
反射是 Java 语言中的一种强大机制，允许程序在运行时动态地获取类的信息、访问类的成员（包括字段、方法和构造函数）以及操作这些成员。
通过反射，您可以：
在运行时获取类的名称、父类、实现的接口等信息。
访问和修改对象的私有字段的值。
调用对象的私有方法。
在运行时创建类的实例。
反射的主要类和接口包括：
Class类：表示一个类或接口在 Java 运行时的对象。
Field类：表示类的字段。
Method类：表示类的方法。
Constructor类：表示类的构造函数。
二. java.lang.Class类
java.lang.Class 类在 Java 反射机制中起着核心作用。
它用于表示正在运行的 Java 应用程序中的类和接口。通过这个类，可以获取关于类的各种信息，如类的名称、属性、方法、父类、实现的接口等。
以下是 Class 类的一些常见方法和用途：
forName(String className)：根据类的全限定名加载并返回对应的Class对象。
getSimpleName()：获取类的简单名称（不包含包名）。
getCanonicalName()：获取类的规范名称（包含包名）。
getSuperclass()：获取父类的Class对象。
getInterfaces()：获取实现的接口的Class对象数组。
getDeclaredFields()：获取本类声明的所有字段（包括私有字段）。
getFields()：获取本类及父类的所有公有字段。
getDeclaredMethods()：获取本类声明的所有方法（包括私有方法）。
getMethods()：获取本类及父类的所有公有方法。
newInstance()：创建类的新实例（调用无参构造函数）。
public class ClassExample {
public static void main(String[] args) {
try {
Class<?> clazz = Class.forName("java.util.ArrayList");
System.out.println("类的简单名称: " + clazz.getSimpleName());
System.out.println("类的规范名称: " + clazz.getCanonicalName());
Class<?> superclass = clazz.getSuperclass();
System.out.println("父类: " + superclass.getCanonicalName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
总之，Class 类为 Java 程序在运行时动态获取和操作类的信息提供了强大的支持。
三. java.lang.reflect包
java.lang.reflect 包提供了用于反射操作的类和接口，允许在运行时检查和操作类、方法、字段和构造函数等。
以下是该包中的一些重要类和接口：
Field类：表示类的字段。可以通过它获取和设置字段的值，无论字段是公有、私有还是受保护的。
Method类：代表类的方法。可以获取方法的名称、参数类型、返回类型，并能够在运行时调用方法。
Constructor类：表示类的构造函数。可用于获取构造函数的参数类型，并通过它创建类的实例。
Array类：提供了一些静态方法来操作数组。
使用反射机制虽然强大，但也存在一些潜在的问题。例如，反射可能会破坏封装性，导致代码更难以理解和维护。此外，由于反射需要在运行时进行类型检查和方法调用，可能会带来一定的性能开销。
以下是一个简单的示例，展示如何使用 java.lang.reflect 包中的类获取类的方法信息：
import java.lang.reflect.Method;
public class ReflectPackageExample {
public static void main(String[] args) {
try {
Class<?> clazz = Class.forName("YourClassName");
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println("方法名: " + method.getName());
Class<?>[] parameterTypes = method.getParameterTypes();
System.out.print("参数类型: ");
for (Class<?> parameterType : parameterTypes) {
System.out.print(parameterType.getName() + " ");
}
System.out.println();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
总之，java.lang.reflect 包为 Java 提供了在运行时进行动态类型探索和操作的能力，但应谨慎使用，权衡其带来的灵活性和可能产生的问题。
四. 创建对象
在 Java 中使用反射来创建对象，主要通过以下步骤：
获取要创建对象的类的
Class对象。可以通过Class.forName("全限定类名")或者 对象的getClass()方法来获取。获取类的构造函数。使用
getDeclaredConstructor(参数类型列表)或getConstructor(参数类型列表)方法。通过构造函数创建对象。使用
newInstance(参数值列表)方法。
以下是一个示例代码：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectionObjectCreation {
public static void main(String[] args) {
try {
// 加载类
Class<?> clazz = Class.forName("YourClassName");
// 获取无参构造函数
Constructor<?> constructor = clazz.getConstructor();
// 使用无参构造函数创建对象
Object object = constructor.newInstance();
// 或者获取有参构造函数，并创建对象
Constructor<?> parameterizedConstructor = clazz.getConstructor(String.class);
Object parameterizedObject = parameterizedConstructor.newInstance("Parameter Value");
} catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
需要注意的是，使用反射创建对象可能会导致一些性能开销，并且在实际开发中应谨慎使用，通常用于一些特殊的场景，如依赖注入框架、对象工厂等。
五. 调用方法
在 Java 中使用反射来调用方法，通常按照以下步骤进行：
- 获取要操作的类的
Class对象。- 根据方法名和参数类型获取对应的
Method对象。- 创建类的实例。
- 使用
Method对象的invoke方法来调用方法，并传递实例对象和参数值。
以下是一个示例代码：
import java.lang.reflect.Method;
public class ReflectionMethodInvocation {
public static void main(String[] args) {
try {
// 加载类
Class<?> clazz = Class.forName("YourClassName");
// 获取指定方法
Method method = clazz.getMethod("methodName", parameterTypes);
// 创建对象实例
Object instance = clazz.newInstance();
// 调用方法
method.invoke(instance, parameterValues);
} catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
在上述代码中，您需要将 "YourClassName" 替换为实际的类名，"methodName" 替换为要调用的方法名，parameterTypes 替换为方法参数的类型数组，parameterValues 替换为实际传递的参数值。
使用反射调用方法时要处理可能抛出的各种异常，并且要注意性能和安全性方面的考虑。一般情况下，只有在必要时才使用反射来调用方法，例如在框架或特定的动态场景中。
六. 调用成员变量
在 Java 中使用反射来访问和操作成员变量，可以按照以下步骤进行：
获取要操作的类的
Class对象。根据成员变量名获取对应的
Field对象。如果成员变量是私有访问权限，需要设置可访问性。
对成员变量进行读写操作。
以下是一个示例代码：
import java.lang.reflect.Field;
public class ReflectionFieldAccess {
public static void main(String[] args) {
try {
// 加载类
Class<?> clazz = Class.forName("YourClassName");
// 获取指定成员变量
Field field = clazz.getDeclaredField("fieldName");
// 如果是私有变量，设置可访问性
field.setAccessible(true);
// 创建对象实例
Object instance = clazz.newInstance();
// 读取成员变量的值
Object value = field.get(instance);
System.out.println("Value of the field: " + value);
// 设置成员变量的值
field.set(instance, newValue);
} catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
在上述代码中，将 "YourClassName" 替换为实际的类名，"fieldName" 替换为要操作的成员变量名，newValue 替换为要设置的新值。
使用反射访问私有成员变量时，需要设置可访问性，否则会抛出异常。同时，反射操作可能会影响代码的封装性和安全性，应谨慎使用。