JAVA反射-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_69185019/article/details/144755792

（记录学习）

概念

反射机制主要通过java.lang.reflect包中的类和接口来实现。这种机制使得Java程序能够动态地获取类的内部信息，并直接操作任意对象的内部属性及方法。

操作对象

Class类：
每个类都有一个Class对象，它包含了与类相关的元数据信息。
可以通过Class.forName(String className)获取类的Class对象。
也可以通过对象.getClass()方法获取对象的Class对象。
类名.class（例如String.class）也可以获取Class对象。
Field类：
表示类的成员变量（字段）。
可以使用Class.getDeclaredField(String name)获取某个字段的Field对象。
可以使用Field.get(Object obj)和Field.set(Object obj, Object value)方法读取和设置字段的值。
Method类：
表示类的方法。
可以使用Class.getDeclaredMethod(String name, Class<?>... parameterTypes)获取某个方法的Method对象。
可以使用Method.invoke(Object obj, Object... args)方法调用该方法。
Constructor类：
表示类的构造方法。
可以使用Class.getConstructor(Class<?>... parameterTypes)获取某个构造方法的Constructor对象。
可以使用Constructor.newInstance(Object... initargs)方法创建类的实例。

动态性

反射允许程序在运行时动态地创建对象、调用方法、访问和修改字段等，而无需在编译时知道具体的类名或方法名。
这种动态性使得Java程序能够更加灵活地处理不同的类和方法，特别是在处理框架、插件或需要高度灵活性的应用程序时。

使用场景

框架开发：
许多Java框架（如Spring、Hibernate等）都广泛使用反射来动态地创建对象、注入依赖、调用方法等。
反射使得框架能够灵活地处理不同的类和方法，而无需在编译时知道具体的实现。
调试和测试：
反射可以用于在运行时检查对象的内部状态，这对于调试和测试来说非常有用。
通过反射，可以访问和修改私有字段和方法，从而验证程序的正确性。
动态代理：
反射可以与Java的动态代理机制结合使用，以创建在运行时动态生成的对象代理。
这使得程序能够在不修改现有代码的情况下，为对象添加额外的行为或功能。
注解处理：
反射可以用于读取和处理Java注解，这些注解可以在编译时或运行时提供额外的信息或元数据。
通过反射，可以检查类、方法或字段上是否存在特定的注解，并根据注解的值来执行相应的操作。

注意事项

性能：反射通常比直接代码调用要慢，因为它在运行时动态解析类型和方法。
安全性：反射可以绕过Java的访问控制机制，因此在使用时需要谨慎，尤其是在处理敏感信息时。
异常处理：反射操作可能抛出多种检查异常（如ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException等），因此需要进行适当的异常处理。

实现例子

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }

    private String getName() {
        return name;
    }

    private void setName(String name) {
        this.name = name;
    }
}

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取Person类的Class对象
            Class<?> personClass = Class.forName("Person");

            // 获取构造方法并创建实例
            Constructor<?> constructor = personClass.getConstructor(String.class, int.class);
            Object personInstance = constructor.newInstance("Alice", 30);

            // 获取并调用公共方法
            Method sayHelloMethod = personClass.getMethod("sayHello");
            sayHelloMethod.invoke(personInstance);

            // 获取并访问私有字段
            Field nameField = personClass.getDeclaredField("name");
            nameField.setAccessible(true); // 设置为可访问
            String nameValue = (String) nameField.get(personInstance);
            System.out.println("Name: " + nameValue);

            // 修改私有字段的值
            nameField.set(personInstance, "Bob");
            sayHelloMethod.invoke(personInstance);

            // 获取并调用私有方法
            Method getNameMethod = personClass.getDeclaredMethod("getName");
            getNameMethod.setAccessible(true); // 设置为可访问
            String getNameResult = (String) getNameMethod.invoke(personInstance);
            System.out.println("Private getName() result: " + getNameResult);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}