【Java】网制焦，实也难，0基础，学反射

已于 2024-06-10 19:35:34 修改
阅读量760 收藏 20
点赞数 22
文章标签： java python 开发语言
于 2024-06-10 17:13:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79344902/article/details/139579191
版权

【Java】网制焦，实也难，0基础，学反射

文章目录


本篇博客将介绍反射的基本机制，如何获取Class对象，如何获取构造方法、成员变量、成员方法，以及它们的一些简单应用。

反射的概述

反射是Java语言中一种强大的功能，它允许程序在运行时检查和操作自身的结构。通过反射，我们可以动态地创建对象、调用方法和访问字段，而不需要在编译时知道它们的名字。这种能力使得反射在框架设计、动态代理、注解处理等方面具有广泛的应用。

image-20240606155903637

获取Class对象的三种方式

在Java中，获取Class对象有三种主要方式：

通过对象的getClass()方法

String str = "Hello";
Class<?> clazz = str.getClass();

通过类的静态属性class

Class<?> clazz = String.class;

通过Class.forName()方法

try {
    Class<?> clazz = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

通过反射获取构造方法

反射提供了多种方法来获取和使用构造方法：

获取所有公共构造方法

Constructor<?>[] constructors = clazz.getConstructors();

获取所有构造方法（包括私有、受保护、默认和公共）

Constructor<?>[] constructors = clazz.getDeclaredConstructors();
获取指定参数类型的公共构造方法
Constructor<T> constructor = clazz.getConstructor(parameterTypes);
获取指定参数类型的构造方法（包括私有、受保护、默认和公共）
Constructor<T> constructor = clazz.getDeclaredConstructor(parameterTypes);

示例

import java.lang.reflect.Constructor;

public class ReflectExample {
    public ReflectExample() {}
    
    private ReflectExample(String name) {
        System.out.println("Name: " + name);
    }

    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = ReflectExample.class;

            // 获取所有公共构造方法
            Constructor<?>[] constructors = clazz.getConstructors();
            for (Constructor<?> constructor : constructors) {
                System.out.println("公共构造方法: " + constructor);
            }

            // 获取所有构造方法
            Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
            for (Constructor<?> constructor : declaredConstructors) {
                System.out.println("所有构造方法: " + constructor);
            }

            // 获取指定参数类型的公共构造方法
            Constructor<?> publicConstructor = clazz.getConstructor();
            System.out.println("公共构造方法: " + publicConstructor);

            // 获取指定参数类型的私有构造方法
            Constructor<?> privateConstructor = clazz.getDeclaredConstructor(String.class);
            privateConstructor.setAccessible(true); // 取消 Java 语言访问检查
            ReflectExample instance = (ReflectExample) privateConstructor.newInstance("Reflection");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

通过反射实例化一个类

定义示例类

public class Person {
    private String name;
    private int age;

    // 默认构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

通过反射实例化类

import java.lang.reflect.Constructor;

public class ReflectionInstantiateExample {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = Person.class;

            // 通过默认构造方法实例化对象
            Constructor<?> defaultConstructor = clazz.getConstructor();
            Person person1 = (Person) defaultConstructor.newInstance();
            System.out.println("使用默认构造方法实例化: " + person1);

            // 通过带参数的构造方法实例化对象
            Constructor<?> paramConstructor = clazz.getConstructor(String.class, int.class);
            Person person2 = (Person) paramConstructor.newInstance("Alice", 30);
            System.out.println("使用带参数的构造方法实例化: " + person2);

            // 使用无参构造方法并通过反射设置属性
            Person person3 = (Person) clazz.getDeclaredConstructor().newInstance();
            clazz.getDeclaredMethod("setName", String.class).invoke(person3, "Bob");
            clazz.getDeclaredMethod("setAge", int.class).invoke(person3, 25);
            System.out.println("通过无参构造方法并设置属性实例化: " + person3);

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

解释

  1. 获取Class对象：
    • 使用Class<?> clazz = Person.class;获取Person类的Class对象。
  2. 获取构造方法：
    • 使用clazz.getConstructor()获取默认构造方法，并通过defaultConstructor.newInstance()实例化对象。
    • 使用clazz.getConstructor(String.class, int.class)获取带参数的构造方法，并通过paramConstructor.newInstance("Alice", 30)实例化对象。
  3. 通过反射设置属性：
    • 使用clazz.getDeclaredMethod("setName", String.class).invoke(person3, "Bob")和clazz.getDeclaredMethod("setAge", int.class).invoke(person3, 25)分别设置name和age属性。

通过反射获取成员变量

反射提供了多种方法来获取类的成员变量：

获取所有公共成员变量

Field[] fields = clazz.getFields();

获取所有成员变量（包括私有、受保护、默认和公共）

Field[] declaredFields = clazz.getDeclaredFields();

获取指定名称的公共成员变量

Field field = clazz.getField("fieldName");

获取指定名称的成员变量（包括私有、受保护、默认和公共）

Field field = clazz.getDeclaredField("fieldName");

示例

import java.lang.reflect.Field;

public class ReflectFieldExample {
    public String publicField;
    private String privateField;

    public ReflectFieldExample() {
        this.publicField = "Public Field";
        this.privateField = "Private Field";
    }

    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = ReflectFieldExample.class;

            // 获取所有公共成员变量
            Field[] fields = clazz.getFields();
            for (Field field : fields) {
                System.out.println("公共成员变量: " + field);
            }

            // 获取所有成员变量
            Field[] declaredFields = clazz.getDeclaredFields();
            for (Field field : declaredFields) {
                System.out.println("所有成员变量: " + field);
            }

            // 获取指定名称的公共成员变量
            Field publicField = clazz.getField("publicField");
            System.out.println("公共成员变量: " + publicField);

            // 获取指定名称的私有成员变量
            Field privateField = clazz.getDeclaredField("privateField");
            privateField.setAccessible(true); // 取消 Java 语言访问检查
            ReflectFieldExample instance = new ReflectFieldExample();
            System.out.println("私有成员变量的值: " + privateField.get(instance));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

通过反射获取成员方法

反射提供了多种方法来获取类的成员方法：

获取所有公共方法

Method[] methods = clazz.getMethods();

获取所有方法（包括私有、受保护、默认和公共）

Method[] declaredMethods = clazz.getDeclaredMethods();

获取指定名称和参数类型的公共方法

Method method = clazz.getMethod("methodName", parameterTypes);

获取指定名称和参数类型的方法（包括私有、受保护、默认和公共）

Method method = clazz.getDeclaredMethod("methodName", parameterTypes);

示例

import java.lang.reflect.Method;

public class ReflectMethodExample {
    public void publicMethod() {
        System.out.println("Public Method");
    }

    private void privateMethod(String message) {
        System.out.println("Private Method: " + message);
    }

    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = ReflectMethodExample.class;

            // 获取所有公共方法
            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                System.out.println("公共方法: " + method);
            }

            // 获取所有方法
            Method[] declaredMethods = clazz.getDeclaredMethods();
            for (Method method : declaredMethods) {
                System.out.println("所有方法: " + method);
            }

            // 获取指定名称的公共方法
            Method publicMethod = clazz.getMethod("publicMethod");
            publicMethod.invoke(new ReflectMethodExample());

            // 获取指定名称的私有方法
            Method privateMethod = clazz.getDeclaredMethod("privateMethod", String.class);
            privateMethod.setAccessible(true); // 取消 Java 语言访问检查
            privateMethod.invoke(new ReflectMethodExample(), "Hello Reflection");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

通过反射调用成员方法

步骤

获取Class对象：

  • 通过类名、对象实例、或Class.forName()方法获取类的Class对象。

获取方法对象：

  • 使用getMethod()或getDeclaredMethod()方法获取对应的Method对象。

调用方法：

  • 使用Method对象的invoke()方法来调用目标方法。

以下是一个详细的示例，展示如何通过反射调用类中的方法，包括公共方法和私有方法。

定义示例类
public class Person {
    private String name;
    private int age;

    // 默认构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法
    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    // 带参数的公共方法
    public void setName(String name) {
        this.name = name;
    }

    // 私有方法
    private void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}
通过反射调用方法
import java.lang.reflect.Method;

public class ReflectionMethodExample {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = Person.class;

            // 创建实例
            Person person = (Person) clazz.getDeclaredConstructor().newInstance();

            // 调用无参数的公共方法
            Method printInfoMethod = clazz.getMethod("printInfo");
            printInfoMethod.invoke(person);

            // 调用带参数的公共方法
            Method setNameMethod = clazz.getMethod("setName", String.class);
            setNameMethod.invoke(person, "Alice");
            printInfoMethod.invoke(person);

            // 调用私有方法
            Method setAgeMethod = clazz.getDeclaredMethod("setAge", int.class);
            setAgeMethod.setAccessible(true); // 取消Java语言访问检查
            setAgeMethod.invoke(person, 30);
            printInfoMethod.invoke(person);

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

获取Class对象：

  • Class<?> clazz = Person.class; 通过类名获取Class对象。

创建实例：

  • Person person = (Person) clazz.getDeclaredConstructor().newInstance(); 使用无参构造方法创建Person类的实例。

调用无参数的公共方法：

  • Method printInfoMethod = clazz.getMethod("printInfo"); 获取printInfo方法的Method对象。
  • printInfoMethod.invoke(person); 调用printInfo方法。

调用带参数的公共方法：

  • Method setNameMethod = clazz.getMethod("setName", String.class); 获取setName方法的Method对象。
  • setNameMethod.invoke(person, "Alice"); 调用setName方法并传递参数"Alice"。

调用私有方法：

  • Method setAgeMethod = clazz.getDeclaredMethod("setAge", int.class); 获取setAge方法的Method对象。
  • setAgeMethod.setAccessible(true); 取消Java语言访问检查，以便调用私有方法。
  • setAgeMethod.invoke(person, 30); 调用setAge方法并传递参数30。

通过反射机制，我们可以动态地操作类的结构和行为，这使得Java语言在一些动态需求场景中更加灵活和强大。但也需要注意的是，反射的使用会带来一些性能上的开销，并且如果滥用反射，可能会导致代码的可读性和维护性下降。因此，在使用反射时需要谨慎，确保其必要性和合理性。

反射的好处及应用场景

反射具有以下好处：

  1. 灵活性：反射允许在运行时动态操作对象和类，这对创建通用框架和库非常有用。
  2. 动态代理：反射是动态代理机制的基础，广泛应用于AOP（面向切面编程）、事务管理等领域。
  3. 运行时检查：反射可以在运行时检查类的属性和方法，用于序列化、依赖注入等。

典型的应用场景包括：

  1. 框架设计：如Spring框架使用反射实现依赖注入、Bean管理等功能。
  2. 测试工具：JUnit等测试框架使用反射来调用测试方法和设置测试环境。
  3. 动态代理：Java的动态代理机制依赖反射实现，如Java的标准库中的java.lang.reflect.Proxy。

关于动态代理：

【Java】试问：你小汁就是我的代理类吗？（动态代理）-CSDN博客

结语

反射方法繁多，初次学，笔者也晕头转向不知如何运用比较好，姑且先将基础的笔记放在这里，以便日后复看复查。

参考：

黑马Java进阶教程，轻松掌握Java反射原理_哔哩哔哩_bilibili

吃汉堡吃到饱
关注
  • 22
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值