[Java基础系列第3弹]Java反射技术全攻略：从入门到精通

Gavana.

已于 2023-08-04 09:04:50 修改

阅读量169

点赞数 1

分类专栏： Java 文章标签： java 开发语言

于 2023-08-03 08:44:18 首次发布

本文链接：https://blog.csdn.net/TaloyerG/article/details/132074985

版权

Java 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

如果你是一个Java开发者，你一定知道反射技术是Java开发中非常重要和强大的一个技术，它可以让你在运行时动态地获取和操作类或者对象的信息和行为，从而实现更灵活和更强大的功能。但是你是否真正掌握了反射技术的概念、作用、原理和用法呢？你是否了解了反射技术的高级技巧和注意事项呢？你是否跟上了反射技术的最新发展和趋势呢？在这篇博客文章中，我将带你深入了解反射技术的方方面面，让你从入门到精通。

一、什么是反射

反射（Reflection）是Java语言的一个特性，它可以让我们在运行时（Runtime）动态地获取和操作类（Class）的信息和对象（Object）的行为。通常情况下，当我们编写Java代码时，我们需要在编译时（Compile Time）就确定好类的名称、属性、方法等信息，以及对象的创建、调用等操作。但是有些时候，我们可能需要在运行时才能知道类的名称或者对象的类型，或者我们需要根据不同的条件来执行不同的方法或者构造不同的对象。这时候，如果我们只能使用编译时的信息和操作，就会非常麻烦和困难。而如果我们能够使用反射技术，就可以在运行时获取类的信息和对象的类型，并且可以动态地创建对象、调用方法、修改属性等，从而实现更灵活和更强大的功能。

那么为什么我们需要使用反射技术呢？反射技术有什么作用呢？实际上，反射技术在Java开发中有很多应用场景，比如：

框架开发：很多流行的Java框架，比如Spring、Hibernate、MyBatis等，都是基于反射技术来实现核心功能的。比如Spring框架可以通过反射来实现依赖注入（DI），即根据配置文件或者注解来动态地创建对象并且注入到其他对象中；Hibernate框架可以通过反射来实现对象关系映射（ORM），即根据配置文件或者注解来动态地将数据库中的表和字段映射到Java中的类和属性；MyBatis框架可以通过反射来实现动态SQL语句的生成和执行，即根据配置文件或者注解来动态地构造SQL语句并且将结果集映射到Java中的对象。
动态代理：动态代理是一种设计模式，它可以让我们在运行时动态地创建一个代理对象（Proxy Object），并且将某个目标对象（Target Object）传递给代理对象，使得代理对象可以拦截目标对象的所有方法调用，并且在方法调用前后执行一些额外的逻辑。这样可以实现很多功能，比如日志记录、权限检查、事务管理等。Java提供了两种方式来实现动态代理，一种是基于接口的JDK动态代理，另一种是基于类的CGLIB动态代理。这两种方式都是基于反射技术来实现的，即通过反射来获取目标对象的类或者接口信息，并且通过反射来创建代理对象和调用目标对象的方法。
注解处理：注解（Annotation）是Java语言的一个特性，它可以让我们在代码中添加一些元数据（Metadata），用来描述类、属性、方法等的一些信息或者行为。比如我们可以使用@Override注解来表示一个方法是重写父类的方法，或者使用@Test注解来表示一个方法是一个单元测试方法。注解本身没有任何功能，它只是一种标记，需要通过反射技术来获取和处理注解，才能实现一些功能。比如JUnit框架可以通过反射来获取和执行所有使用@Test注解的方法，从而实现单元测试的功能；Spring框架可以通过反射来获取和处理所有使用@Autowired注解的属性，从而实现依赖注入的功能。

以上只是反射技术的一些典型应用场景，实际上还有很多其他的应用场景，比如JavaBeans、XML解析、JSON解析等。可以说，反射技术是Java开发中不可或缺的一个技术，它可以让我们编写出更灵活和更强大的代码。

二、如何使用反射

要想使用反射技术，我们首先需要了解Java中关于反射的核心类和接口，它们都位于java.lang.reflect包下。这些类和接口主要有以下几个：

Class：这个类代表了Java中的一个类或者接口，它包含了类或者接口的名称、修饰符、父类、接口、构造器、方法、属性等信息。我们可以通过Class对象来获取和操作类或者接口的信息和行为。Class对象是反射技术的入口，要想使用反射技术，我们首先需要获取Class对象。
Field：这个类代表了Java中的一个属性或者成员变量，它包含了属性或者成员变量的名称、修饰符、类型等信息。我们可以通过Field对象来获取和操作属性或者成员变量的值。
Method：这个类代表了Java中的一个方法或者函数，它包含了方法或者函数的名称、修饰符、返回值类型、参数类型等信息。我们可以通过Method对象来获取和执行方法或者函数。
Constructor：这个类代表了Java中的一个构造器或者构造方法，它包含了构造器或者构造方法的修饰符、参数类型等信息。我们可以通过Constructor对象来创建对象实例。
Modifier：这个类提供了一些静态方法和常量，用来操作和判断修饰符（Modifier），比如public、private、static、final等。

除了以上这些类之外，还有一些其他的类和接口，比如Array、Proxy、InvocationHandler等，它们也是反射技术中常用到的。我们在后面会介绍它们的作用和用法。

那么如何获取Class对象呢？有以下三种方式：

通过类名.class：如果我们已经知道类名，那么我们可以直接使用类名.class来获取Class对象。比如String.class就表示String类对应的Class对象。
通过对象.getClass()：如果我们已经有一个对象实例，那么我们可以通过对象.getClass()方法来获取Class对象。比如"Hello".getClass()就表示"Hello"字符串对应的Class对象。
通过Class.forName()：如果我们只知道类名字符串，那么我们可以通过Class.forName()静态方法来获取Class对象。比如Class.forName(“java.lang.String”)就表示String类对应的Class对象。

三、反射的高级技巧和注意事项

在上一节中，介绍了如何使用反射来获取和操作类的信息和对象的行为，以及一些基本的示例代码。在这一节中，将介绍一些反射的高级技巧，比如如何使用泛型和注解来增强反射的能力，如何使用动态代理来实现AOP，以及如何使用ClassLoader来加载不同来源的类等。还将提醒注意一些反射的缺点和风险，比如性能开销、安全问题、异常处理等。

1. 使用泛型和注解

泛型（Generics）是Java语言的一个特性，它可以让我们在编写代码时不指定具体的类型，而是使用类型参数（Type Parameter）来表示类型，从而实现代码的复用和类型安全。比如我们可以定义一个泛型类List<E>，其中E是一个类型参数，表示列表中元素的类型。然后我们可以创建不同类型的列表对象，比如List<String>、List<Integer>等，而不需要为每种类型都定义一个单独的类。

注解（Annotation）是Java语言的另一个特性，它可以让我们在代码中添加一些元数据（Metadata），用来描述类、属性、方法等的一些信息或者行为。比如我们可以使用@Override注解来表示一个方法是重写父类的方法，或者使用@Test注解来表示一个方法是一个单元测试方法。

那么泛型和注解有什么关系呢？实际上，泛型和注解都是在编译时起作用的特性，它们都会被编译器处理掉，并且不会保留到运行时。这就导致了一个问题：如果我们使用反射来获取和操作类或者对象时，我们无法获取到泛型或者注解的信息。比如如果我们使用Class.forName(“java.util.List”)来获取List类对应的Class对象，我们无法知道这个List类是什么类型参数；如果我们使用"Hello".getClass()来获取String对象对应的Class对象，我们无法知道这个String对象是否有任何注解。

为了解决这个问题，Java提供了一些特殊的类和接口来表示泛型或者注解相关的信息，并且通过反射技术来获取和操作这些信息。这些类和接口主要有以下几个：

Type：这个接口代表了Java中的一个类型，它是所有类型相关的接口和类的父接口。它有以下几个子接口：
- ParameterizedType：这个接口代表了一个参数化类型，即带有类型参数的类型。比如List<String>就是一个参数化类型，它有一个类型参数String。我们可以通过ParameterizedType接口来获取参数化类型的原始类型（Raw Type）和实际类型参数（Actual Type Argument）。比如对于List<String>这个参数化类型，它的原始类型是List.class，它的实际类型参数是String.class。
- GenericArrayType：这个接口代表了一个泛型数组类型，即数组元素是泛型类型的数组。比如List<String>[]就是一个泛型数组类型，它的数组元素是List<String>这个泛型类型。我们可以通过GenericArrayType接口来获取泛型数组类型的组件类型（Component Type）。比如对于List<String>[]这个泛型数组类型，它的组件类型是List<String>这个参数化类型。
- TypeVariable：这个接口代表了一个类型变量，即在定义泛型类或者方法时使用的类型参数。比如在定义List<E>这个泛型类时，E就是一个类型变量。我们可以通过TypeVariable接口来获取类型变量的名称、边界（Bound）和声明位置（Generic Declaration）。比如对于List<E>这个泛型类中的类型变量E，它的名称是E，它的边界是Object，它的声明位置是List.class。
- WildcardType：这个接口代表了一个通配符类型，即在使用泛型类或者方法时使用的通配符表达式。比如List<?>就是一个通配符类型，它表示任意类型的列表。我们可以通过WildcardType接口来获取通配符类型的上边界（Upper Bound）和下边界（Lower Bound）。比如对于List<?>这个通配符类型，它的上边界是Object，它的下边界是null。
AnnotatedElement：这个接口代表了一个可以被注解的元素，它是所有可以被注解的类和接口的父接口。它有以下几个子接口：
- Class：这个类代表了一个类或者接口，它实现了AnnotatedElement接口，表示一个类或者接口可以被注解。我们可以通过Class对象来获取和操作类或者接口上的注解。
- Field：这个类代表了一个属性或者成员变量，它实现了AnnotatedElement接口，表示一个属性或者成员变量可以被注解。我们可以通过Field对象来获取和操作属性或者成员变量上的注解。
- Method：这个类代表了一个方法或者函数，它实现了AnnotatedElement接口，表示一个方法或者函数可以被注解。我们可以通过Method对象来获取和操作方法或者函数上的注解。
- Constructor：这个类代表了一个构造器或者构造方法，它实现了AnnotatedElement接口，表示一个构造器或者构造方法可以被注解。我们可以通过Constructor对象来获取和操作构造器或者构造方法上的注解。
- Parameter：这个类代表了一个方法或者构造器的参数，它实现了AnnotatedElement接口，表示一个参数可以被注解。我们可以通过Parameter对象来获取和操作参数上的注解。

通过以上这些类和接口，我们就可以使用反射技术来获取和操作泛型或者注解相关的信息。下面我们来看一些示例代码：

// 获取List<String>对应的ParameterizedType对象
ParameterizedType pt = (ParameterizedType) List.class.getGenericInterfaces()[0];
// 获取List<String>的原始类型
Class<?> rawType = (Class<?>) pt.getRawType();
System.out.println(rawType); // class java.util.List
// 获取List<String>的实际类型参数
Type[] actualTypeArguments = pt.getActualTypeArguments();
System.out.println(actualTypeArguments[0]); // class java.lang.String

// 获取String[]对应的GenericArrayType对象
GenericArrayType gat = (GenericArrayType) Class.forName("[Ljava.lang.String;").getGenericSuperclass();
// 获取String[]的组件类型
Type componentType = gat.getGenericComponentType();
System.out.println(componentType); // class java.lang.String

// 获取List<E>中E对应的TypeVariable对象
TypeVariable<?> tv = List.class.getTypeParameters()[0];
// 获取E的名称
System.out.println(tv.getName()); // E
// 获取E的边界
System.out.println(tv.getBounds()[0]); // class java.lang.Object
// 获取E的声明位置
System.out.println(tv.getGenericDeclaration()); // interface java.util.List

// 获取List<?>对应的WildcardType对象
WildcardType wt = (WildcardType) List.class.getGenericInterfaces()[0].getActualTypeArguments()[0];
// 获取?的上边界
System.out.println(wt.getUpperBounds()[0]); // class java.lang.Object
// 获取?的下边界
System.out.println(wt.getLowerBounds().length); // 0

// 定义一个带有注解的类
@Deprecated
public class Person {
    @NotNull
    private String name;
    @Range(min = 1, max = 150)
    private int age;

    public Person(@NotNull String name, @Range(min = 1, max = 150) int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 获取Person类对应的Class对象
Class<?> personClass = Person.class;
// 获取Person类上的注解
Annotation[] annotations = personClass.getAnnotations();
for (Annotation annotation : annotations) {
    System.out.println(annotation); // @java.lang.Deprecated()
}
// 获取Person类的name属性对应的Field对象
Field nameField = personClass.getDeclaredField("name");
// 获取name属性上的注解
Annotation[] nameAnnotations = nameField.getAnnotations();
for (Annotation annotation : nameAnnotations) {
    System.out.println(annotation); // @NotNull()
}
// 获取Person类的age属性对应的Field对象
Field ageField = personClass.getDeclaredField("age");
// 获取age属性上的注解
Annotation[] ageAnnotations = ageField.getAnnotations();
for (Annotation annotation : ageAnnotations) {
    System.out.println(annotation); // @Range(min=1, max=150)
}
// 获取Person类的构造器对应的Constructor对象
Constructor<?> personConstructor = personClass.getConstructor(String.class, int.class);
// 获取构造器上的注解
Annotation[][] parameterAnnotations = personConstructor.getParameterAnnotations();
for (int i = 0; i < parameterAnnotations.length; i++) {
    System.out.println("Parameter " + i + ":");
    for (Annotation annotation : parameterAnnotations[i]) {
        System.out.println(annotation);
        // Parameter 0:
        // @NotNull()
        // Parameter 1:
        // @Range(min=1, max=150)
    }
}
// 获取Person类的toString方法对应的Method对象
Method toStringMethod = personClass.getMethod("toString");
// 获取toString方法上的注解
Annotation[] methodAnnotations = toStringMethod.getAnnotations();
for (Annotation annotation : methodAnnotations) {
    System.out.println(annotation); // @Override()
}

我们可以看到，通过反射技术，我们可以在运行时获取到泛型或者注解的信息，并且可以根据这些信息来实现一些功能。比如我们可以根据注解来进行参数校验、日志记录、权限控制等。

2. 使用动态代理

动态代理（Dynamic Proxy）是一种设计模式，它可以让我们在运行时动态地创建一个代理对象（Proxy Object），并且将某个目标对象（Target Object）传递给代理对象，使得代理对象可以拦截目标对象的所有方法调用，并且在方法调用前后执行一些额外的逻辑。这样可以实现很多功能，比如日志记录、权限检查、事务管理等。动态代理也是一种基于反射技术的技术，即通过反射来获取目标对象的类或者接口信息，并且通过反射来创建代理对象和调用目标对象的方法。

Java提供了两种方式来实现动态代理，一种是基于接口的JDK动态代理，另一种是基于类的CGLIB动态代理。这两种方式都需要实现一个InvocationHandler接口，它是一个函数式接口，它只有一个方法invoke(Object proxy, Method method, Object[] args)，它表示当代理对象调用某个方法时，会执行这个方法。在这个方法中，我们可以获取到代理对象、目标对象、目标方法和目标参数，并且可以在调用目标方法前后执行一些额外的逻辑。下面我们来看一些示例代码：

// 定义一个接口
public interface HelloService {
    void sayHello(String name);
}

// 定义一个实现类
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
}

// 定义一个日志处理器，实现InvocationHandler接口
public class LogHandler implements InvocationHandler {
    // 目标对象
    private Object target;

    // 构造方法，传入目标对象
    public LogHandler(Object target) {
        this.target = target;
    }

    // 重写invoke方法，实现代理逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用目标方法前，打印日志
        System.out.println("Log: " + method.getName() + " is invoked with " + Arrays.toString(args));
        // 调用目标方法，获取返回值
        Object result = method.invoke(target, args);
        // 在调用目标方法后，打印日志
        System.out.println("Log: " + method.getName() + " is finished with " + result);
        // 返回结果
        return result;
    }
}

// 使用JDK动态代理来创建代理对象
HelloService helloService = new HelloServiceImpl(); // 创建目标对象
LogHandler logHandler = new LogHandler(helloService); // 创建日志处理器，传入目标对象
HelloService proxy = (HelloService) Proxy.newProxyInstance( // 创建代理对象，传入类加载器、接口数组和处理器
        helloService.getClass().getClassLoader(),
        helloService.getClass().getInterfaces(),
        logHandler);
proxy.sayHello("Alice"); // 调用代理对象的方法，会触发处理器的invoke方法

// 输出结果：
// Log: sayHello is invoked with [Alice]
// Hello, Alice
// Log: sayHello is finished with null

// 使用CGLIB动态代理来创建代理对象
Enhancer enhancer = new Enhancer(); // 创建增强器对象
enhancer.setSuperclass(HelloServiceImpl.class); // 设置父类为目标类
enhancer.setCallback(logHandler); // 设置回调为日志处理器
HelloService proxy2 = (HelloService) enhancer.create(); // 创建代理对象
proxy2.sayHello("Bob"); // 调用代理对象的方法，会触发处理器的invoke方法

// 输出结果：
// Log: sayHello is invoked with [Bob]
// Hello, Bob
// Log: sayHello is finished with null

我们可以看到，通过动态代理技术，我们可以在不修改目标类或者接口的情况下，为它们添加一些额外的功能。比如我们可以使用动态代理来实现AOP（面向切面编程），即将一些通用的功能（比如日志、事务、权限等）抽象成切面（Aspect），并且将这些切面应用到不同的目标对象上，从而实现功能的解耦和复用。

四、反射的发展和趋势

1. 反射相关的新技术和新特性

随着Java语言的不断发展和更新，反射技术也在不断地适应和改进。在近几年中，Java引入了一些新的技术和特性，它们都与反射技术有着密切的关系。比如：

Java 9中引入的模块化系统（Module System）：模块化系统是Java 9中最重要的特性之一，它可以让我们将Java应用程序划分为不同的模块（Module），每个模块都有自己的名称、依赖、导出和开放等信息。模块化系统可以提高Java应用程序的封装性、安全性和性能，但是它也对反射技术带来了一些影响和限制。比如，如果一个模块没有导出或者开放某个包（Package），那么其他模块就无法通过反射来访问这个包中的类或者成员；如果一个模块没有读取（Read）或者使用（Use）另一个模块，那么它就无法通过反射来创建或者调用这个模块中的类或者成员。为了解决这些问题，Java提供了一些方法和工具来支持在模块化系统中使用反射技术。比如，我们可以使用–add-exports或者–add-opens选项来增加模块的导出或者开放信息；我们可以使用–add-reads或者–add-modules选项来增加模块的读取或者使用信息；我们可以使用java.lang.reflect.Module类来获取和操作模块相关的信息。
Java 14中引入的记录类（Record Class）：记录类是Java 14中引入的一个预览特性（Preview Feature），它可以让我们定义一个不可变且简洁的数据类（Data Class），它只包含一些数据字段（Data Field），并且自动提供了构造器、访问器、equals、hashCode、toString等方法。记录类可以简化我们编写数据类时的代码量和重复性，但是它也对反射技术带来了一些影响和支持。比如，我们可以通过反射来获取记录类的组件类型（Component Type），即记录类中数据字段对应的类型；我们可以通过反射来创建记录类的实例，并且设置其数据字段的值；我们可以通过反射来调用记录类自动生成的方法，并且获取其返回值。为了支持这些功能，Java提供了一些方法和工具来支持在反射技术中使用记录类。比如，我们可以使用java.lang.Class.isRecord()方法来判断一个类是否是记录类；我们可以使用java.lang.Class.getRecordComponents()方法来获取记录类的组件数组；我们可以使用java.lang.reflect.RecordComponent接口来表示记录类的组件，并且获取其名称、类型、注解等信息。
Java 16中引入的虚拟线程（Virtual Thread）：虚拟线程是Java 16中引入的一个预览特性（Preview Feature），它可以让我们创建大量且轻量级的线程（Thread），它们不直接映射到操作系统的线程，而是由Java虚拟机（JVM）来调度和管理。虚拟线程可以提高Java应用程序的并发性、响应性和效率，但是它也对反射技术带来了一些挑战和变化。比如，由于虚拟线程的数量可能远远超过操作系统线程的数量，因此我们无法通过反射来获取或者修改虚拟线程的优先级（Priority）或者状态（State）等信息；由于虚拟线程的执行可能会被JVM随时暂停或者恢复，因此我们无法通过反射来中断（Interrupt）或者等待（Join）虚拟线程的完成等操作。为了适应这些变化，Java提供了一些方法和工具来支持在反射技术中使用虚拟线程。比如，我们可以使用java.lang.Thread.isVirtual()方法来判断一个线程是否是虚拟线程；我们可以使用java.lang.Thread.ofVirtual()方法来创建一个虚拟线程；我们可以使用java.lang.Thread.ofPlatform()方法来创建一个平台线程，即操作系统的线程。

以上展示了Java语言的不断创新和进步，也展示了反射技术的不断适应和改进。当然，这些技术和特性都还在不断地发展和完善中，可能会有一些变化和更新。因此，我们作为Java开发者，需要时刻关注Java语言的最新动态和趋势，以及反射技术的最新影响和支持。

2. 反射技术可能面临的挑战和变化

虽然反射技术是Java开发中非常重要和强大的一个技术，但是它也不是完美无缺的。在使用反射技术时，我们也需要注意一些反射技术可能面临的挑战和变化。比如：

性能开销：使用反射技术会带来一定的性能开销，因为反射技术需要在运行时动态地获取和操作类或者对象的信息和行为，这些操作都需要消耗一定的时间和内存。而且由于反射技术会破坏编译器的优化，因此使用反射技术可能会降低程序的运行速度。因此，在使用反射技术时，我们需要权衡好性能和灵活性之间的平衡，避免过度或者不必要地使用反射技术。
安全问题：使用反射技术会带来一定的安全问题，因为反射技术可以让我们访问和修改一些本来不可见或者不可变的类或者对象。比如我们可以通过反射技术来访问和修改私有属性或者方法，或者改变final属性或者类的值等。这些操作可能会破坏类或者对象的封装性、完整性和一致性，从而导致程序出现错误或者异常。而且如果我们不小心将反射技术暴露给外部用户或者攻击者，那么他们可能会利用反射技术来执行一些恶意的操作，比如获取或者修改敏感信息、执行恶意代码等。因此，在使用反射技术时，我们需要注意好安全性和可控性之间的平衡，避免滥用或者泄露反射技术。
异常处理：使用反射技术会带来一定的异常处理问题，因为反射技术会在运行时动态地获取和操作类或者对象的信息和行为，这些操作可能会抛出一些异常（Exception），比如ClassNotFoundException、NoSuchFieldException、NoSuchMethodException、IllegalAccessException、InvocationTargetException等。这些异常都是受检异常（Checked Exception），即在编译时就需要被捕获（Catch）或者声明（Throw）的异常。如果我们不处理这些异常，那么程序就会终止运行，并且显示错误信息。因此，在使用反射技术时，我们需要注意好异常处理，避免程序出现意外的错误或者崩溃。我们可以使用try-catch-finally语句来捕获和处理异常，或者使用throws关键字来声明异常，让调用者来处理异常。下面我们来看一些示例代码：

// 使用反射技术来创建一个String对象
try {
    // 获取String类对应的Class对象
    Class<?> stringClass = Class.forName("java.lang.String");
    // 获取String类的无参构造器对应的Constructor对象
    Constructor<?> stringConstructor = stringClass.getConstructor();
    // 通过Constructor对象来创建一个String对象
    String string = (String) stringConstructor.newInstance();
    // 打印String对象的值
    System.out.println(string); // 空字符串
} catch (ClassNotFoundException e) {
    // 处理找不到类的异常
    e.printStackTrace();
} catch (NoSuchMethodException e) {
    // 处理找不到方法的异常
    e.printStackTrace();
} catch (InstantiationException e) {
    // 处理实例化失败的异常
    e.printStackTrace();
} catch (IllegalAccessException e) {
    // 处理访问权限的异常
    e.printStackTrace();
} catch (InvocationTargetException e) {
    // 处理调用目标方法抛出的异常
    e.printStackTrace();
}

// 使用反射技术来修改一个final属性的值
try {
    // 创建一个Integer对象
    Integer integer = new Integer(10);
    // 获取Integer类对应的Class对象
    Class<?> integerClass = integer.getClass();
    // 获取Integer类的value属性对应的Field对象
    Field valueField = integerClass.getDeclaredField("value");
    // 设置value属性可访问
    valueField.setAccessible(true);
    // 通过Field对象来修改value属性的值
    valueField.set(integer, 20);
    // 打印Integer对象的值
    System.out.println(integer); // 20
} catch (NoSuchFieldException e) {
    // 处理找不到属性的异常
    e.printStackTrace();
} catch (IllegalAccessException e) {
    // 处理访问权限的异常
    e.printStackTrace();
}

五、总结

反射技术是Java开发中非常重要和强大的一个技术，它可以让我们在运行时动态地获取和操作类或者对象的信息和行为，从而实现更灵活和更强大的功能。反射技术在Java开发中有很多应用场景，比如框架开发、动态代理、注解处理等。反射技术也是一种基于反射技术的技术，它可以让我们在不修改目标类或者接口的情况下，为它们添加一些额外的功能。反射技术也是一种不断发展和改进的技术，它可以适应和支持Java语言的不断创新和进步。

当然，反射技术也不是完美无缺的。在使用反射技术时，我们也需要注意一些反射技术可能面临的挑战和变化。比如性能开销、安全问题、异常处理等。因此，在使用反射技术时，我们需要权衡好性能和灵活性之间的平衡，注意好安全性和可控性之间的平衡，以及注意好异常处理。

总之，反射技术是Java开发中不可或缺的一个技术，它可以让我们编写出更灵活和更强大的代码。希望本文能够对你有所帮助，让你对反射技术有一个更深入和全面的了解。

这里是热爱编程的小高，希望对来访读者有所帮助😊

Gavana.

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
[Java基础系列第3弹]Java反射技术全攻略：从入门到精通

反射（Reflection）是Java语言的一个特性，它可以让我们在运行时（Runtime）动态地获取和操作类（Class）的信息和对象（Object）的行为。通常情况下，当我们编写Java代码时，我们需要在编译时（Compile Time）就确定好类的名称、属性、方法等信息，以及对象的创建、调用等操作。但是有些时候，我们可能需要在运行时才能知道类的名称或者对象的类型，或者我们需要根据不同的条件来执行不同的方法或者构造不同的对象。这时候，如果我们只能使用编译时的信息和操作，就会非常麻烦和困难。
复制链接

扫一扫