一、Java反射核心类：
1、Class类：
表示Java类的实例，可以用于获取类的信息，如类名、父类、接口、字段、方法等。可以使用Class.forName()方法根据类名获取Class对象，或者使用对象的getClass()方法获取Class对象。
下面是一个简单的示例代码，演示如何使用反射获取类的信息：
public class Main {
public static void main(String[] args) {
try {
// 使用Class.forName()方法获取Class对象
Class<?> clazz = Class.forName("com.example.MyClass");
// 获取类名
String className = clazz.getName();
System.out.println("Class Name: " + className);
// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println("Super Class: " + superClass.getName());
// 获取接口
Class<?>[] interfaces = clazz.getInterfaces();
System.out.println("Implemented Interfaces:");
for (Class<?> interfaceClass : interfaces) {
System.out.println(interfaceClass.getName());
}
// 获取字段
Field[] fields = clazz.getDeclaredFields();
System.out.println("Fields:");
for (Field field : fields) {
System.out.println(field.getName());
}
// 获取方法
Method[] methods = clazz.getDeclaredMethods();
System.out.println("Methods:");
for (Method method : methods) {
System.out.println(method.getName());
}
// 获取构造器
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
System.out.println("Constructors:");
for (Constructor<?> constructor : constructors) {
System.out.println(constructor.getName());
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class MyClass extends BaseClass implements MyInterface {
private int id;
public String name;
public MyClass(int id, String name) {
this.id = id;
this.name = name;
}
public void printInfo() {
System.out.println("ID: " + id);
System.out.println("Name: " + name);
}
}
class BaseClass {
// 父类
}
interface MyInterface {
// 接口
}
输出结果：
Class Name: com.example.MyClass
Super Class: com.example.BaseClass
Implemented Interfaces:
com.example.MyInterface
Fields:
id
name
Methods:
printInfo
Constructors:
com.example.MyClass
2、Constructor类：
表示类的构造方法，可以用于创建类的实例。可以使用Class类的getConstructor()方法或getDeclaredConstructor()方法获取Constructor对象，然后使用newInstance()方法创建实例。
下面是一个简单的示例演示如何使用构造方法创建类的实例：
import java.lang.reflect.Constructor;
class MyClass {
private String name;
public MyClass(String name) {
this.name = name;
}
public void printName() {
System.out.println("Name: " + name);
}
}
public class Main {
public static void main(String[] args) throws Exception {
// 获取 MyClass 类的构造方法
Constructor<MyClass> constructor = MyClass.class.getConstructor(String.class);
// 使用构造方法创建类的实例
MyClass myClass = constructor.newInstance("John");
// 调用实例方法
myClass.printName();
}
}
在上面的示例中，我们首先使用MyClass.class.getConstructor(String.class)获取了MyClass类的构造方法对象，该构造方法接受一个String类型的参数。然后，我们使用constructor.newInstance(“John”)来创建一个实例，参数"John"将作为构造方法的参数传递进去。最后，我们调用了实例方法printName()来打印实例的名称。
3、Field类：
表示类的字段，可以用于获取和设置字段的值。可以使用Class类的getField()方法或getDeclaredField()方法获取Field对象，然后使用get()方法获取字段的值，或者使用set()方法设置字段的值。
下面是一个简单的示例演示如何使用字段获取和设置字段的值：
import java.lang.reflect.Field;
class MyClass {
public String name;
private int age;
public MyClass(String name, int age) {
this.name = name;
this.age = age;
}
public void printInfo() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
public class Main {
public static void main(String[] args) throws Exception {
// 创建 MyClass 实例
MyClass myClass = new MyClass("John", 25);
// 获取 MyClass 类的 name 字段
Field nameField = MyClass.class.getField("name");
// 获取 MyClass 类的 age 字段
Field ageField = MyClass.class.getDeclaredField("age");
ageField.setAccessible(true); // 设置私有字段可访问
// 获取字段的值
String nameValue = (String) nameField.get(myClass);
int ageValue = (int) ageField.get(myClass);
System.out.println("Name: " + nameValue);
System.out.println("Age: " + ageValue);
// 设置字段的值
nameField.set(myClass, "Alice");
ageField.set(myClass, 30);
myClass.printInfo();
}
}
在上面的示例中，我们创建了一个MyClass类的实例，并且使用getField()方法获取了name字段的Field对象，使用getDeclaredField()方法获取了age字段的Field对象。getDeclaredField()方法可以获取私有字段，但私有字段默认是不可访问的，因此我们需要调用setAccessible(true)来设置私有字段可访问。
然后，我们使用get()方法分别获取了name字段和age字段的值，并使用set()方法将name字段的值设置为"Alice"，将age字段的值设置为30。最后，我们调用printInfo()方法来打印字段的值，验证字段的值是否已经被修改。注意，需要进行类型转换来获取和设置字段的值。
4、Method类：
表示类的方法，可以用于调用方法。可以使用Class类的getMethod()方法或getDeclaredMethod()方法获取Method对象，然后使用invoke()方法调用方法。
下面是一个使用反射调用类的方法的示例代码：
import java.lang.reflect.Method;
class MyClass {
public void myMethod() {
System.out.println("调用了myMethod方法");
}
}
public class Main {
public static void main(String[] args) throws Exception {
// 获取MyClass类的Class对象
Class<?> clazz = MyClass.class;
// 获取myMethod方法的Method对象
Method method = clazz.getMethod("myMethod");
// 创建MyClass类的实例
MyClass myObj = new MyClass();
// 调用myMethod方法
method.invoke(myObj);
}
}
输出结果：
调用了myMethod方法
在上面的代码中，我们首先通过MyClass.class获取了MyClass类的Class对象。然后使用getMethod()方法传入方法名来获取myMethod方法的Method对象。
接着，我们创建了MyClass类的实例myObj。
最后，我们使用invoke()方法来调用myMethod方法，传入myObj作为方法的调用者。这样就成功地调用了myMethod方法。
需要注意的是，如果myMethod方法是私有方法或者是继承自父类的方法，需要使用getDeclaredMethod()方法获取Method对象。并且在调用invoke()方法之前，需要先调用setAccessible(true)来设置方法的可访问性。
二、反射的底层原理
-
在Java程序的执行过程中，首先需要将源代码进行编译，生成对应的字节码文件（.class文件）。然后，JVM会加载这些字节码文件，并在方法区中创建对应的类信息，包括类的名称、父类、接口、字段、方法等。
-
反射就是通过获取这些类信息的方式，来实现对类的动态操作。通过获取类的Class对象，可以获取类的名称、父类、接口等信息。
通过Class对象的方法，可以获取类的构造器、字段、方法等成员信息，并可以动态地创建对象、调用方法、访问字段等。 -
反射的机制使得程序能够在运行时动态地获取和操作类的信息，而不需要在编译时就确定类的结构。这为框架的开发、动态代理、配置文件的读取等提供了便利。但是需要注意的是，反射的使用可能会带来一定的性能损耗，因此在性能要求高的场景中需要谨慎使用。