【从零开始学习JAVA | 第四十五篇】反射

梦里梦外; 2023-10-14 17:12 48阅读 0赞

**目录**

前言：

反射：

使用反射的步骤：

1.获取阶段：

2.使用阶段：

反射的应用场景：

使用反射的优缺点：

总结：

--------------------

## 前言： ##

Java中的反射是一项强大而灵活的功能，它允许程序在运行时动态地获取、操作和利用类的信息。通过反射，我们可以在运行时检查和修改类的属性、调用类的方法，甚至创建和操作对象实例。这种能力为Java提供了很多灵活性和扩展性，使得我们能够编写更加通用、可插拔和动态的代码。然而，反射也是一种高级特性，需要谨慎使用，因为它可能牺牲了一些性能和类型安全性。在本文中，我们将深入探究Java反射的原理、用法和最佳实践。

## ![3be353b8db804522a42eb1c91b82be12.png][]反射： ##

反射是一种在运行时动态获取、检查和操作类的信息的能力。它允许程序在运行时通过类的名称获取其完整结构，并可以实例化对象、调用方法、访问属性和执行其他与类相关的操作，而无需在编译时明确引用这些类。**反射的核心是java.lang.reflect包**，它提供了一组类和接口，用于实现反射功能。使用反射，可以实现一些灵活和通用的编程技术，如动态加载类、配置文件解析、框架扩展和代码生成。然而，反射也会带来性能上的开销，并且**破坏了编译时类型检查**，因此在使用时需要注意适度和合理性。

> 也就是说：反射可以把类中的成员变量，成员方法和构造方法单独拿出来进行访问，我们是否会好奇我们自定义类之后，idea为什么会有提示功能？
> 
> ![423b9ab4d41746cea193083d405adb1d.png][]
> 
> 其实这就是通过**反射**来实现的。

## 使用反射的步骤： ##

### 1.获取阶段： ###

在获取阶段，我们使用反射机制来获取与类、方法、字段等相关的信息。这包括获取类的Class对象、构造方法、方法、字段等，并可以检查类的继承关系、接口实现以及注解等元数据信息。获取阶段提供了对类结构的探索和解析的能力，让我们能够动态地获取类的结构信息。

(1)利用反射获取class对象

public class test01 {
        public static void main(String[] args) throws ClassNotFoundException {
            //获取class文件：
            //第一种
            Class<?> aClass = Class.forName("Myrflect.student");
            System.out.println(aClass);
    
            //第二种：
            Class<student> studentClass = student.class;
            System.out.println(studentClass);
    
            //第三种：
            student st = new student();
            Class<? extends student> aClass1 = st.getClass();
            System.out.println(aClass1);
    
        }
    }

(2)利用反射获得构造方法

public class getcontrbute {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
            //1.获取字节码文件对象
            Class<?> aClass = Class.forName("Myrflect.student");
            
            //1.获取公共的构造方法：
            Constructor<?>[] constructors = aClass.getConstructors();
            for (Constructor<?> constructor : constructors) {
                System.out.println(constructor);
            }
            System.out.println("-------------------------");
            
            //2.获取私有的构造方法
            Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
            for (Constructor<?> cons : declaredConstructors) {
                System.out.println(cons);
            }
            System.out.println("-------------------------");
            
            //3.获取单个的构造方法
            Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
            System.out.println(declaredConstructor);
            Constructor<?> declaredConstructor1 = aClass.getDeclaredConstructor(String.class,int.class,String.class);
            System.out.println(declaredConstructor1);
            
        }
    }

(3)反射获取成员变量

public class getmember {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
            //1.获取Class字节码文件对象
            Class<?> aClass = Class.forName("Myrflect.student");
    
            //1.获取所有公告成员变量对象的数组
            Field[] fields = aClass.getFields();
            for (Field field : fields) {
                System.out.println(field);
            }
            System.out.println("---------------");
            //2.获取所有成员变量对象的数组
            Field[] declaredFields = aClass.getDeclaredFields();
            for (Field field : declaredFields) {
                System.out.println(field);
            }
            System.out.println("---------------");
            //3.获取单个成员变量
            Field name = aClass.getField("name");
            System.out.println(name);
        }
    }

(4)反射获取成员方法

public class getway {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
            Class<?> aClass = Class.forName("Myrflect.student");
    
            //1.获取所有公共方法对象(包含父类，而每一个类都继承Object类，因此打印会出现很多方法)
            Method[] methods = aClass.getMethods();
            for (Method method : methods) {
                System.out.println(method);
            }
            System.out.println("-----------------------------");
            //2.获取所有方法对象(不包含父类)
            Method[] declaredMethods = aClass.getDeclaredMethods();
            for (Method method : declaredMethods) {
                System.out.println(method);
            }
            System.out.println("-----------------------------");
            //3.获取单个方法
            Method method = aClass.getMethod("getAge");
            System.out.println(method);
    
        }
    }

### 2.使用阶段： ###

在获取了类的结构信息后，我们可以使用反射机制来动态地实例化对象、调用方法、访问字段等操作。使用阶段利用获取阶段得到的信息，通过反射来操作类的成员，实现灵活、通用和动态的功能。使用阶段可以根据实际需求来动态地操作类的成员，而无需在编译时提前确定具体的类和成员。

public class ReflectionExample {
        public static void main(String[] args) {
            try {
                // 读取和写入字段
                MyClass obj = new MyClass();
                Class<?> clazz = obj.getClass();
                
                // 获取公共字段
                Field publicField = clazz.getField("publicField");
                System.out.println("Public Field Initial Value: " + publicField.get(obj));
                
                // 设置字段的值
                publicField.set(obj, "New Value");
                System.out.println("Public Field Updated Value: " + publicField.get(obj));
                
                // 获取私有字段
                Field privateField = clazz.getDeclaredField("privateField");
                privateField.setAccessible(true); // 设置私有字段可访问
                System.out.println("Private Field Initial Value: " + privateField.get(obj));
                
                // 设置私有字段的值
                privateField.set(obj, 123);
                System.out.println("Private Field Updated Value: " + privateField.get(obj));
                
                // 调用方法
                Method method = clazz.getMethod("publicMethod");
                method.invoke(obj); // 执行公共方法
                
                // 创建对象
                Constructor<?> constructor = clazz.getConstructor();
                Object newObj = constructor.newInstance();
                System.out.println("New Object: " + newObj);
            } catch (NoSuchFieldException | IllegalAccessException | NoSuchMethodException | InvocationTargetException | InstantiationException e) {
                e.printStackTrace();
            }
        }
    }

反射还提供了许多其他功能，如获取类的构造方法、接口、父类，获取注解信息等。

需要注意的是，使用反射时要注意权限的限制（如私有成员的访问）以及性能问题（反射操作比直接调用性能较差）。另外，运用反射应尽量遵循设计原则，避免滥用反射，保证代码的可读性和可维护性。

## 反射的应用场景： ##

1.  **框架开发**：反射常被用于框架的开发，通过读取配置文件或注解来动态地加载类、创建对象、调用方法和访问字段，从而实现灵活可扩展的框架结构。
2.  **对象实例化**：通过反射可以实现动态地创建对象实例。通过类的`Constructor`对象可以调用不同的构造方法，为对象传递不同的参数，从而根据需要来创建对象。
3.  **调用方法和访问字段**：反射可以用于调用类的方法和访问类的字段。通过方法的`Method`对象可以调用类的不同方法，通过字段的`Field`对象可以读取和写入类的字段值。
4.  **探索类的信息**：通过反射可以获取类的详细信息，如类名、父类、接口、方法和字段等。这对于编写通用的代码和进行类似于文档生成、序列化和验证等操作非常有用。
5.  **动态代理**：反射在实现动态代理时发挥了重要作用。通过反射可以动态地生成代理类，并在代理类的方法调用中添加额外的逻辑，如日志记录、权限验证等。
6.  **单元测试**：反射可以用于编写单元测试时的Mock对象。通过反射可以创建假对象并模拟实际对象的行为，从而进行更全面的单元测试。

## 使用反射的优缺点： ##

优点：

1.  **动态性**：反射提供了在运行时动态获取和操作类的能力。可以动态地创建对象、调用方法和访问字段，这使得代码更具灵活性和可扩展性。
2.  **通用性**：通过反射可以编写通用的代码，不依赖于具体的类和接口。可以在不了解类结构的情况下获取类的信息，并根据需要来操作类的成员。
3.  **框架支持**：反射被广泛应用于框架的开发，框架可以通过读取配置文件或注解来动态加载类和创建对象，从而实现灵活可配置的框架结构。
4.  **灵活性**：反射使得可以在运行时根据条件来动态地选择和执行代码，而不是在编译时进行静态绑定。这在某些特定的业务场景下非常有用。例如，根据配置文件动态选择不同的实现类。

缺点：

1.  **性能开销**：反射通常比直接调用代码要慢，因为它需要进行额外的查找、检查和调用。反射调用的性能开销相对较高，可能对性能敏感的应用程序需要谨慎使用。
2.  **安全性问题**：使用反射可以绕过类的访问控制和安全检查机制，这可能导致安全漏洞。因此，在使用反射时，需要保证代码的安全性，并确保只有受信任的代码可以访问敏感操作。
3.  **编译器检查缺失**：反射可以让代码更加动态，但也会失去编译器在代码编译阶段进行错误检查的能力。一些错误可能在运行时才能被发现，增加了调试的困难性。

## 总结： ##

反射是Java中的一项强大功能，通过它我们可以在运行时动态地获取和操作类的成员。使用反射可以实现灵活性、通用性和动态性，提供了诸如创建对象、调用方法和访问字段等功能。然而，反射也有一些缺点，如性能开销和安全性问题。因此，在使用反射时需要权衡利弊，确保使用安全可靠，并遵循最佳实践。总之，反射为Java程序提供了更大的灵活性和扩展性，使代码编写更加通用且适应动态变化的需求。

如果我的内容对你有帮助，请**点赞，评论，收藏**。创作不易，大家的支持就是我坚持下去的动力！

![69e9169c980f43e0aad31ff9ada88a9c.png][]

[3be353b8db804522a42eb1c91b82be12.png]: https://img-blog.csdnimg.cn/3be353b8db804522a42eb1c91b82be12.png
[423b9ab4d41746cea193083d405adb1d.png]: https://img-blog.csdnimg.cn/423b9ab4d41746cea193083d405adb1d.png
[69e9169c980f43e0aad31ff9ada88a9c.png]: https://img-blog.csdnimg.cn/69e9169c980f43e0aad31ff9ada88a9c.png