Java 反射学习总结（附代码示例）🪞

关于本文

本文是笔者忘痕在 B 站学习 Java 反射相关课程后整理的笔记与代码练习，内容主要来自课程讲解，仅作学习交流，如有疏漏欢迎指正；文章排版与可读性由 DeepSeek-V4-Flash 协助做了优化。

📖 本文导读#

本文会讲述 Java 反射的相关知识以及代码演示，希望对你有所帮助。反射是 Java 里比较「玄」、但又是框架底层经常用到的机制，跟着代码一步步看，就能把它从「魔法」变成「工具」。

阅读提醒

反射会频繁出现 Class、Constructor、Field、Method 这些词，别被它们吓到——它们分别代表「字节码文件对象」「构造方法」「成员变量」「成员方法」，后面每个都有示例。

文章路线图，照着走不迷路：

🔍 什么是反射 —— 专业解释 + 通俗理解
🎯 获取字节码文件对象（Class）的三种方式
🧬 字节码文件与字节码文件对象
🧱 获取构造方法并创建对象
📦 获取成员变量并取值 / 改值
⚙️ 获取成员方法并运行
💾 用反射把对象信息保存到文件
🔧 反射 + 配置文件，动态创建对象并调用方法

🔍 什么是反射？#

专业的解释（了解一下即可）：

在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法。这种动态获取信息以及动态调用对象方法的功能，称为 Java 语言的反射机制。

通俗的理解（重点掌握）：

利用反射创建的对象，可以无视修饰符调用类里面的内容
可以跟配置文件结合起来使用，把要创建的对象信息和方法写在配置文件中：
- 读取到什么类，就创建什么类的对象
- 读取到什么方法，就调用什么方法
- 此时当需求变更时不需要修改代码，只要修改配置文件即可

一句话理解

反射 = 「在运行期间，把类当成对象去研究」：先拿到类的字节码文件对象（Class），再从它身上把构造方法、成员变量、成员方法一个一个抓出来用。

反射都是从类的字节码文件中获取字段（成员变量）、构造方法、成员方法——这个操作可以理解为「获取」；拿到这些之后，就能获取里面的任何东西，比如修饰符、参数、数据类型、名字……这个操作可以理解为「解剖」。

那反射具体要学什么？

如何获取 Class 字节码文件对象
利用反射如何获取构造方法（创建对象）
利用反射如何获取成员变量（赋值、取值）
利用反射如何获取成员方法（运行）

🎯 获取字节码文件对象的三种方式#

获取 Class 对象（字节码文件对象）有三种方式：

Class 类里的静态方法 forName("全类名") —— 最常用（全类名 = 包名 + 类名）
通过 class 属性获取（类名.class）
通过对象获取（对象.getClass()）

代码演示：

1
// 1. Class 这个类里面的静态方法 forName
2
// Class.forName("类的全类名")：全类名 = 包名 + 类名
3
// 最常用的
4
Class clazz1 = Class.forName("com.wanghen.reflectdemo.Student");
5
// 源代码阶段获取 —— 先把 Student 加载到内存中，再获取字节码文件对象
6
// clazz1 就表示 Student 这个类的字节码文件对象
7
// 就是当 Student.class 这个文件加载到内存之后，产生的字节码文件对象
8

9
// 2. 通过 class 属性获取
10
// 类名.class
11
// 一般更多的是当做参数去传递
12
Class clazz2 = Student.class;
13

14
// 因为 class 文件在硬盘中是唯一的，所以，当这个文件加载到内存之后产生的对象也是唯一的
15
System.out.println(clazz1 == clazz2);// true
16

17
// 3. 通过 Student 对象获取字节码文件对象
18
// 当已经有了这个类的对象才能去使用
19
Student s = new Student();
20
Class clazz3 = s.getClass();
21
System.out.println(clazz1 == clazz2);// true
22
System.out.println(clazz2 == clazz3);// true

三种方式拿到的是同一个对象

无论用哪种方式，同一个类的字节码文件对象在内存中是唯一的，所以上面三个 clazz 用 == 比较都是 true。

🧬 字节码文件和字节码文件对象#

先看清三个概念的区别：

java 文件：我们自己编写的 Java 代码
字节码文件：java 文件编译之后的 .class 文件，在硬盘上真实存在，用眼睛能看到
字节码文件对象：当 .class 文件加载到内存之后，虚拟机自动创建出来的对象

这个对象里面至少包含了：构造方法、成员变量、成员方法。

反射获取的是什么？

反射获取的是 字节码文件对象（Class），而这个对象在内存中是唯一的。拿到它，就能「解剖」出构造方法、成员变量和成员方法。

🧱 获取构造方法并创建对象#

命名规则（记一下）

get：表示获取
Declared：表示私有（能拿到私有修饰的）
最后的 s：表示所有、复数形式
如果拿到的是私有的，必须临时修改访问权限（setAccessible(true)），否则无法使用

Class 类中获取构造方法的方法：

方法名	说明
`Constructor<?>[] getConstructors()`	获得所有构造（只能 public 修饰）
`Constructor<?>[] getDeclaredConstructors()`	获得所有构造（包含 private 修饰）
`Constructor<T> getConstructor(Class<?>... parameterTypes)`	获取指定构造（只能 public 修饰）
`Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)`	获取指定构造（包含 private 修饰）

Constructor 类中用于创建对象的方法：

方法名	说明
`T newInstance(Object... initargs)`	用构造方法创建对象，参数要和构造方法里的参数保持一致
`void setAccessible(boolean flag)`	临时取消权限校验（暴力反射），用于操作私有成员

Constructor 类中其他常用方法（代码里用到的）：

方法名	说明
`int getModifiers()`	获取构造方法的权限修饰符
`int getParameterCount()`	获取参数个数
`Parameter[] getParameters()`	获取这个构造方法中所有参数
`Class<?>[] getParameterTypes()`	获取这个构造方法中参数的类型
`String getName()`	获取构造方法的名字

代码演示 —— 实体类 Student：

1
public class Student {
2
    // 定义属性
3
    private String name;
4
    private int age;
5

6
    // 定义构造方法
7
    public Student() {
8
    }
9

10
    protected Student(String name) {
11
        this.name = name;
12
    }
13

14
    private Student(int age) {
15
        this.age = age;
16
    }
17

18
    public Student(String name, int age) {
19
        this.name = name;
20
        this.age = age;
21
    }
22

23
    // 定义方法
24
    public String getName() {
25
        return name;
26
    }
27

28
    public void setName(String name) {
29
        this.name = name;
30
    }
31

32
    public int getAge() {
33
        return age;
34
    }
35

36
    public void setAge(int age) {
37
        this.age = age;
38
    }
39

40
    @Override
41
    public boolean equals(Object o) {
42
        if (o == null || getClass() != o.getClass()) return false;
43
        Student student = (Student) o;
44
        return age == student.age && Objects.equals(name, student.name);
45
    }
46

47
    @Override
48
    public int hashCode() {
49
        return Objects.hash(name, age);
50
    }
51

52
    @Override
53
    public String toString() {
54
        return "Student{" +
55
                "name='" + name + '\'' +
56
                ", age=" + age +
57
                '}';
58
    }
59
}

代码演示 —— 测试类 reflectDemo1（获取构造并创建对象）：

1
public class reflectDemo1 {
2
    static void main() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
3
        /*
4
            Class 类中用于获取构造方法的方法
5
                Constructor<?>[] getConstructors()                                  获取 public 修饰的所有构造方法
6
                Constructor<?>[] getDeclaredConstructors()                          获取所有权限修饰符修饰的所有构造方法
7
                Constructor<T> getConstructor(Class<?>... parameterTypes)           获取单个 public 修饰的构造方法，参数填构造方法里形参的 class 对象
8
                Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)   获取单个所有权限修饰符修饰的构造方法，参数填构造方法里形参的 class 对象
9
            Constructor 类中用于创建对象的方法
10
                T newInstance(Object... initargs)                                   用构造方法创建对象，参数要和构造方法里的参数保持一致
11
                setAccessible(boolean flag)                                         临时取消权限校验
12
        */
13
        // 获取字节码文件对象
14
        Class clazz = Class.forName("com.wanghen.reflectdemo1.Student");
15

16
        // 获取 public 修饰的所有构造方法
17
        Constructor[] cons1 = clazz.getConstructors();
18
        for (Constructor constructor : cons1) {
19
            System.out.println(constructor);
20
        }
21

22
        System.out.println("==============================================");
23

24
        // 获取所有权限修饰符修饰的所有构造方法
25
        Constructor[] cons2 = clazz.getDeclaredConstructors();
26
        for (Constructor constructor : cons2) {
27
            System.out.println(constructor);
28
        }
29

30
        System.out.println("==============================================");
31

32
        // 获取单个 public 修饰的构造方法，参数填构造方法里形参的 class 对象
33
        Constructor con1 = clazz.getConstructor();
34
        System.out.println(con1);
35
        Constructor con2 = clazz.getConstructor(String.class, int.class);
36
        System.out.println(con2);
37

38
        System.out.println("==============================================");
39

40
        // 获取单个所有权限修饰符修饰的构造方法，参数填构造方法里形参的 class 对象
41
        Constructor con3 = clazz.getDeclaredConstructor(String.class);
42
        System.out.println(con3);
43
        Constructor con4 = clazz.getDeclaredConstructor(int.class);
44
        System.out.println(con4);
45

46
        System.out.println("==============================================");
47

48
        // 用构造方法创建对象，参数要和构造方法里的参数保持一致
49
        Student s = (Student) con2.newInstance("茜特菈莉", 500);
50
        System.out.println(s);
51

52
        // 如果是 private 修饰的构造方法不能直接创建对象，
53
        // 要调用 setAccessible 临时取消权限校验（暴力反射）才能创建
54
        con4.setAccessible(true);
55
        Student student = (Student) con4.newInstance(500);
56
        System.out.println(student);
57

58
        System.out.println("==============================================");
59

60
        // 获取权限修饰符
61
        int modifiers = con2.getModifiers();
62
        System.out.println(modifiers);
63

64
        System.out.println("==============================================");
65

66
        // 获取参数个数
67
        int parameterCount = con2.getParameterCount();
68
        System.out.println(parameterCount);
69

70
        System.out.println("==============================================");
71

72
        // 获取这个构造方法中所有参数
73
        Parameter[] parameters = con2.getParameters();
74
        for (Parameter parameter : parameters) {
75
            System.out.println(parameter);
76
        }
77

78
        System.out.println("==============================================");
79

80
        // 获取这个构造方法中参数的类型
81
        Class[] parameterTypes = con2.getParameterTypes();
82
        for (Class parameterType : parameterTypes) {
83
            System.out.println(parameterType);
84
        }
85

86
        System.out.println("==============================================");
87

88
        // 获取名字
89
        String name = con2.getName();
90
        System.out.println(name);
91

92
        System.out.println("==============================================");
93
    }
94
}

私有成员别直接操作

用 newInstance / set / invoke 操作私有的构造方法、成员变量、成员方法前，一定要先 setAccessible(true)，否则会抛异常。

📦 获取成员变量并获取值和修改值#

命名规则（同上）

get 获取、Declared 私有、最后的 s 表示所有。私有成员要 setAccessible(true) 才能操作。

Class 类中获取成员变量的方法：

方法名	说明
`Field[] getFields()`	返回所有成员变量对象的数组（只能拿 public 的）
`Field[] getDeclaredFields()`	返回所有成员变量对象的数组，存在就能拿到
`Field getField(String name)`	返回单个成员变量对象（只能拿 public 的）
`Field getDeclaredField(String name)`	返回单个成员变量对象，存在就能拿到

Field 类中取值 / 赋值的方法：

方法	说明
`void set(Object obj, Object value)`	赋值
`Object get(Object obj)`	获取值
`void setAccessible(boolean flag)`	临时取消权限校验（私有成员用）

Field 类中其他常用方法（代码里用到的）：

方法	说明
`int getModifiers()`	获取成员变量的权限修饰符
`Class<?> getType()`	获取成员变量的类型
`String getName()`	获取成员变量的名字

代码演示 —— 实体类 Student：

1
public class Student {
2
    // 定义属性
3
    public String gander;
4
    private String name;
5
    private int age;
6

7
    // 定义构造方法
8
    public Student() {
9
    }
10

11
    protected Student(String name) {
12
        this.name = name;
13
    }
14

15
    private Student(int age) {
16
        this.age = age;
17
    }
18

19
    public Student(String name, int age) {
20
        this.name = name;
21
        this.age = age;
22
    }
23

24
    public Student(String gander, String name, int age) {
25
        this.gander = gander;
26
        this.name = name;
27
        this.age = age;
28
    }
29

30
    @Override
31
    public boolean equals(Object o) {
32
        if (o == null || getClass() != o.getClass()) return false;
33
        Student student = (Student) o;
34
        return age == student.age && Objects.equals(gander, student.gander) && Objects.equals(name, student.name);
35
    }
36

37
    @Override
38
    public int hashCode() {
39
        return Objects.hash(gander, name, age);
40
    }
41

42
    public String getGander() {
43
        return gander;
44
    }
45

46
    public void setGander(String gander) {
47
        this.gander = gander;
48
    }
49

50
    @Override
51
    public String toString() {
52
        return "Student{" +
53
                "gander='" + gander + '\'' +
54
                ", name='" + name + '\'' +
55
                ", age=" + age +
56
                '}';
57
    }
58

59
    public String getName() {
60
        return name;
61
    }
62

63
    public void setName(String name) {
64
        this.name = name;
65
    }
66

67
    public int getAge() {
68
        return age;
69
    }
70

71
    public void setAge(int age) {
72
        this.age = age;
73
    }
74
}

代码演示 —— 测试类 reflectDemo2（获取成员变量并取值 / 赋值）：

1
public class reflectDemo2 {
2
    static void main() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
3
        /*
4
            Class 类中用于获取成员变量的方法
5
                Field[] getFields():                            返回所有公共成员变量对象的数组
6
                Field[] getDeclaredFields():                    返回所有成员变量对象的数组
7
                Field getField(String name):                    返回单个公共成员变量对象
8
                Field getDeclaredField(String name):            返回单个成员变量对象
9
            Field 类中用于取值 / 赋值的方法
10
                void set(Object obj, Object value):             赋值
11
                Object get(Object obj)                          获取值
12
        */
13
        // 获取 Student 的字节码文件对象
14
        Class clazz = Class.forName("com.wanghen.reflectdemo2.Student");
15

16
        System.out.println("==============================");
17

18
        // 返回所有公共成员变量对象的数组
19
        Field[] fields1 = clazz.getFields();
20
        for (Field field : fields1) {
21
            System.out.println(field);
22
        }
23

24
        System.out.println("==============================");
25

26
        // 返回所有成员变量对象的数组
27
        Field[] fields2 = clazz.getDeclaredFields();
28
        for (Field field : fields2) {
29
            System.out.println(field);
30
        }
31

32
        System.out.println("==============================");
33

34
        // 返回单个公共成员变量对象
35
        Field gander = clazz.getField("gander");
36
        System.out.println(gander);
37

38
        System.out.println("==============================");
39

40
        // 返回单个成员变量对象
41
        Field name = clazz.getDeclaredField("name");
42
        System.out.println(name);
43

44
        System.out.println("==============================");
45

46
        // 获取成员变量的权限修饰符
47
        int modifiers1 = gander.getModifiers();
48
        System.out.println(modifiers1);
49
        int modifiers2 = name.getModifiers();
50
        System.out.println(modifiers2);
51

52
        System.out.println("==============================");
53

54
        // 获取成员变量的类型
55
        Class type1 = gander.getType();
56
        Class type2 = name.getType();
57
        System.out.println(type1);
58
        System.out.println(type2);
59

60
        System.out.println("==============================");
61

62
        // 获取成员变量的名字
63
        String name1 = gander.getName();
64
        String name2 = name.getName();
65
        System.out.println(name1);
66
        System.out.println(name2);
67

68
        System.out.println("==============================");
69

70
        // 获取值 —— 成员变量的值是创建对象之后才有的，所以要取值得先有对象
71
        Student student = new Student("女", "茜特菈莉", 500);
72

73
        // 获取这个对象里面的 gander 这个成员变量的值
74
        String str1 = (String) gander.get(student);
75
        System.out.println(str1);
76

77
        // 因为成员变量是私有的，不能直接获取，所以要临时取消权限检测
78
        name.setAccessible(true);
79
        String str2 = (String) name.get(student);
80
        System.out.println(str2);
81

82
        System.out.println("==============================");
83

84
        // 赋值 —— 赋值也得先有对象；修改的是 private 成员变量，所以要 setAccessible
85
        name.setAccessible(true);
86
        name.set(student, "芙宁娜");
87
        System.out.println(student);
88
    }
89
}

记住了：取值、赋值都要「先有对象」

成员变量的值存在于具体的对象上，所以 get / set 的第一个参数必须传一个对象，告诉它「去哪个对象上取 / 改」。

⚙️ 获取成员方法并运行#

命名规则（同上）

get 获取、Declared 私有、最后的 s 所有。私有方法要 setAccessible(true) 才能运行。

Class 类中获取成员方法的方法：

方法名	说明
`Method[] getMethods()`	返回所有成员方法对象的数组（只能拿 public 的，包括继承的）
`Method[] getDeclaredMethods()`	返回所有成员方法对象的数组（存在就能拿到，不包括继承的）
`Method getMethod(String name, Class<?>... parameterTypes)`	返回单个成员方法对象（只能拿 public 的）
`Method getDeclaredMethod(String name, Class<?>... parameterTypes)`	返回单个成员方法对象，存在就能拿到

Method 类中运行方法的方法：

方法	说明
`Object invoke(Object obj, Object... args)`	运行方法。参数一：用 obj 对象调用该方法；参数二：方法实参（没有就不写）；返回值：方法返回值（没有就不写）
`void setAccessible(boolean flag)`	临时取消权限校验（私有方法用）

Method 类中其他常用方法（代码里用到的）：

方法	说明
`int getModifiers()`	获取方法的修饰符
`String getName()`	获取方法的名字
`Parameter[] getParameters()`	获取方法的形参
`Class<?> getReturnType()`	获取方法的返回值类型
`Class<?>[] getExceptionTypes()`	获取方法声明的抛出的异常

代码演示 —— 实体类 Student：

1
public class Student {
2
    // 定义属性
3
    public String gander;
4
    private String name;
5
    private int age;
6

7
    // 定义构造方法
8
    public Student() {
9
    }
10

11
    protected Student(String name) {
12
        this.name = name;
13
    }
14

15
    private Student(int age) {
16
        this.age = age;
17
    }
18

19
    public Student(String name, int age) {
20
        this.name = name;
21
        this.age = age;
22
    }
23

24
    public Student(String gander, String name, int age) {
25
        this.gander = gander;
26
        this.name = name;
27
        this.age = age;
28
    }
29

30
    @Override
31
    public boolean equals(Object o) {
32
        if (o == null || getClass() != o.getClass()) return false;
33
        Student student = (Student) o;
34
        return age == student.age && Objects.equals(gander, student.gander) && Objects.equals(name, student.name);
35
    }
36

37
    @Override
38
    public int hashCode() {
39
        return Objects.hash(gander, name, age);
40
    }
41

42
    public String getGander() {
43
        return gander;
44
    }
45

46
    public void setGander(String gander) {
47
        this.gander = gander;
48
    }
49

50
    @Override
51
    public String toString() {
52
        return "Student{" +
53
                "gander='" + gander + '\'' +
54
                ", name='" + name + '\'' +
55
                ", age=" + age +
56
                '}';
57
    }
58

59
    public String getName() {
60
        return name;
61
    }
62

63
    public void setName(String name) {
64
        this.name = name;
65
    }
66

67
    public int getAge() {
68
        return age;
69
    }
70

71
    public void setAge(int age) {
72
        this.age = age;
73
    }
74

75
    public void sleep() {
76
        System.out.println("睡觉");
77
    }
78

79
    private void eat(String something) throws RuntimeException {
80
        System.out.println("吃" + something);
81
    }
82

83
    private int eat(String something, int times) {
84
        System.out.println("吃" + something + "" + times + "次");
85
        return 1;
86
    }
87
}

代码演示 —— 测试类 reflectDemo3（获取成员方法并运行）：

1
public class reflectDemo3 {
2
    static void main() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
3
        /*
4
            Class 类中用于获取成员方法的方法
5
                Method[] getMethods():                         返回所有公共成员方法对象的数组，包括继承的
6
                Method[] getDeclaredMethods():                 返回所有成员方法对象的数组，不包括继承的
7
                Method getMethod(String name, Class<?>... parameterTypes)     返回单个公共成员方法对象
8
                Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回单个成员方法对象
9

10
            Method 类中用于运行方法的方法
11
                Object invoke(Object obj, Object... args)：运行方法
12
                参数一：用 obj 对象调用该方法
13
                参数二：调用方法的传递的参数（如果没有就不写）    返回值：方法的返回值（如果没有就不写）
14
            还可以获取：方法的修饰符、方法的名字、方法的形参、方法的返回值、方法抛出的异常
15
        */
16
        // 获取字节码文件对象
17
        Class clazz = Class.forName("com.wanghen.reflectdemo3.Student");
18

19
        System.out.println("====================================================");
20

21
        // 返回所有公共成员方法对象的数组，包括继承的
22
        Method[] methods1 = clazz.getMethods();
23
        for (Method method : methods1) {
24
            System.out.println(method);
25
        }
26

27
        System.out.println("====================================================");
28

29
        // 返回所有成员方法对象的数组，不包括继承的
30
        Method[] methods2 = clazz.getDeclaredMethods();
31
        for (Method method : methods2) {
32
            System.out.println(method);
33
        }
34

35
        System.out.println("====================================================");
36

37
        // 返回单个公共成员方法对象
38
        // 参数一：方法名；参数二：形参类型（因为可以有重载的方法）
39
        Method setAge = clazz.getMethod("setAge", int.class);
40
        System.out.println(setAge);
41

42
        System.out.println("====================================================");
43

44
        // 返回单个成员方法对象
45
        Method eat = clazz.getDeclaredMethod("eat", String.class);
46
        System.out.println(eat);
47

48
        System.out.println("====================================================");
49

50
        // 获取方法修饰符
51
        int modifiers = eat.getModifiers();
52
        System.out.println(modifiers);
53

54
        System.out.println("====================================================");
55

56
        // 获取方法的名字
57
        String name = eat.getName();
58
        System.out.println(name);
59

60
        System.out.println("====================================================");
61

62
        // 获取方法的形参
63
        Parameter[] parameters = eat.getParameters();
64
        for (Parameter parameter : parameters) {
65
            System.out.println(parameter);
66
        }
67

68
        System.out.println("====================================================");
69

70
        // 获取方法抛出的异常
71
        Class[] exceptionTypes = eat.getExceptionTypes();
72
        for (Class exceptionType : exceptionTypes) {
73
            System.out.println(exceptionType);
74
        }
75

76
        System.out.println("====================================================");
77

78
        // 运行方法 —— 运行方法得靠对象运行
79
        /*
80
            Object invoke(Object obj, Object... args)：运行方法
81
            参数一：用 obj 对象调用该方法
82
            参数二：调用方法的传递的参数（如果没有就不写）    返回值：方法的返回值（如果没有就不写）
83
        */
84
        Student student = new Student();
85

86
        // 因为是私有方法不能直接运行，所以要先临时取消权限检查
87
        eat.setAccessible(true);
88
        eat.invoke(student, "苹果");
89

90
        System.out.println("====================================================");
91

92
        // 获取方法返回值
93
        Method eat1 = clazz.getDeclaredMethod("eat", String.class, int.class);
94
        eat1.setAccessible(true);
95
        Object i = eat1.invoke(student, "苹果", 2);
96
        System.out.println(i);
97

98
        System.out.println("====================================================");
99
    }
100
}

invoke 是反射核心

invoke(obj, args) 就是「在 obj 上运行这个方法」：第一个参数是对象，第二个是方法实参；私有方法运行前先 setAccessible(true)。这一招就是框架底层「调用任意方法」的真相。

💾 利用反射保存对象中的信息#

需求

对于任意一个对象，都把它的所有字段名和值，保存到文件中去。

代码演示 —— 实体类 Student：

1
public class Student {
2
    private String name;
3
    private int age;
4
    private String gander;
5
    private double high;
6
    private String hobby;
7

8
    public Student() {
9
    }
10

11
    public Student(String name, int age, String gander, double high, String hobby) {
12
        this.name = name;
13
        this.age = age;
14
        this.gander = gander;
15
        this.high = high;
16
        this.hobby = hobby;
17
    }
18

19
    public String getName() { return name; }
20
    public void setName(String name) { this.name = name; }
21
    public int getAge() { return age; }
22
    public void setAge(int age) { this.age = age; }
23
    public String getGander() { return gander; }
24
    public void setGander(String gander) { this.gander = gander; }
25
    public double getHigh() { return high; }
26
    public void setHigh(double high) { this.high = high; }
27
    public String getHobby() { return hobby; }
28
    public void setHobby(String hobby) { this.hobby = hobby; }
29

30
    @Override
31
    public boolean equals(Object o) {
32
        if (o == null || getClass() != o.getClass()) return false;
33
        Student student = (Student) o;
34
        return age == student.age && Double.compare(high, student.high) == 0 && Objects.equals(name, student.name) && Objects.equals(gander, student.gander) && Objects.equals(hobby, student.hobby);
35
    }
36

37
    @Override
38
    public int hashCode() {
39
        return Objects.hash(name, age, gander, high, hobby);
40
    }
41

42
    @Override
43
    public String toString() {
44
        return "Student{" +
45
                "name='" + name + '\'' +
46
                ", age=" + age +
47
                ", gander='" + gander + '\'' +
48
                ", high=" + high +
49
                ", hobby='" + hobby + '\'' +
50
                '}';
51
    }
52
}

代码演示 —— 实体类 Teacher：

1
public class Teacher {
2
    private String name;
3
    private int salary;
4

5
    public Teacher() {
6
    }
7

8
    public Teacher(String name, int salary) {
9
        this.name = name;
10
        this.salary = salary;
11
    }
12

13
    public String getName() { return name; }
14
    public void setName(String name) { this.name = name; }
15
    public int getSalary() { return salary; }
16
    public void setSalary(int salary) { this.salary = salary; }
17

18
    @Override
19
    public boolean equals(Object o) {
20
        if (o == null || getClass() != o.getClass()) return false;
21
        Teacher teacher = (Teacher) o;
22
        return salary == teacher.salary && Objects.equals(name, teacher.name);
23
    }
24

25
    @Override
26
    public int hashCode() {
27
        return Objects.hash(name, salary);
28
    }
29

30
    @Override
31
    public String toString() {
32
        return "Teacher{" +
33
                "name='" + name + '\'' +
34
                ", salary=" + salary +
35
                '}';
36
    }
37
}

代码演示 —— 测试类 reflectTest1（把对象字段名和值写到文件）：

1
public class reflectTest1 {
2
    static void main() throws IOException, IllegalAccessException {
3
        /* 对于任意一个对象，都可以把对象所有的字段名和值，保存到文件中去 */
4
        // 创建对象
5
        Student student = new Student("茜特菈莉", 500, "女", 150, "看小说");
6
        Teacher teacher = new Teacher("桑多涅", 10000);
7

8
        // 调用方法把对象字段(成员变量)名跟值写到文件中
9
        putObjInFile(student);
10
    }
11

12
    private static void putObjInFile(Object object) throws IOException, IllegalAccessException {
13
        // 获取这个对象的字节码文件对象
14
        Class clazz = object.getClass();
15
        // 获取字段
16
        Field[] declaredFields = clazz.getDeclaredFields();
17
        // 创建 IO 流
18
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("Day35\\a.txt")));
19
        // 循环获取字段名跟值
20
        for (Field declaredField : declaredFields) {
21
            // 可能是被 public 之外修饰的，不确定能否获取到，所以要临时取消权限检测
22
            declaredField.setAccessible(true);
23
            // 获取名字
24
            String name = declaredField.getName();
25
            // 获取这个字段在这个对象中的值
26
            Object value = declaredField.get(object);
27
            // 把数据写到文件中
28
            bw.write(name + "=" + value);
29
            bw.newLine();
30
        }
31
        // 释放资源
32
        bw.close();
33
    }
34
}

这个例子想说明什么

同样的 putObjInFile 方法，传 Student 或 Teacher 都能自动把它的字段写出来——因为反射不关心具体类型，只关心「这个类有哪些字段、每字段的值」。这就是「对任意对象都能拿到任意属性」。

🔧 反射和配置文件结合动态获取#

需求

利用反射，根据文件中的不同类名和方法名，创建不同的对象并调用方法——需求变更时只需改配置文件，不用改代码。

分析：

通过 Properties 加载配置文件
得到类名和方法名
通过类名反射得到 Class 对象
通过 Class 对象创建一个对象
通过 Class 对象得到方法
调用方法

代码演示 —— 配置文件 prop.properties：

1
classname=com.wanghen.test2.Teacher
2
method=teach

代码演示 —— 实体类 Student：

1
public class Student {
2
    private String name;
3
    private int age;
4
    private String gander;
5
    private double high;
6
    private String hobby;
7

8
    public Student() {
9
    }
10

11
    public Student(String name, int age, String gander, double high, String hobby) {
12
        this.name = name;
13
        this.age = age;
14
        this.gander = gander;
15
        this.high = high;
16
        this.hobby = hobby;
17
    }
18

19
    public String getName() { return name; }
20
    public void setName(String name) { this.name = name; }
21
    public int getAge() { return age; }
22
    public void setAge(int age) { this.age = age; }
23
    public String getGander() { return gander; }
24
    public void setGander(String gander) { this.gander = gander; }
25
    public double getHigh() { return high; }
26
    public void setHigh(double high) { this.high = high; }
27
    public String getHobby() { return hobby; }
28
    public void setHobby(String hobby) { this.hobby = hobby; }
29

30
    public void study() {
31
        System.out.println("学习");
32
    }
33

34
    @Override
35
    public boolean equals(Object o) {
36
        if (o == null || getClass() != o.getClass()) return false;
37
        Student student = (Student) o;
38
        return age == student.age && Double.compare(high, student.high) == 0 && Objects.equals(name, student.name) && Objects.equals(gander, student.gander) && Objects.equals(hobby, student.hobby);
39
    }
40

41
    @Override
42
    public int hashCode() {
43
        return Objects.hash(name, age, gander, high, hobby);
44
    }
45

46
    @Override
47
    public String toString() {
48
        return "Student{" +
49
                "name='" + name + '\'' +
50
                ", age=" + age +
51
                ", gander='" + gander + '\'' +
52
                ", high=" + high +
53
                ", hobby='" + hobby + '\'' +
54
                '}';
55
    }
56
}

代码演示 —— 实体类 Teacher：

1
public class Teacher {
2
    private String name;
3
    private int salary;
4

5
    public Teacher() {
6
    }
7

8
    public Teacher(String name, int salary) {
9
        this.name = name;
10
        this.salary = salary;
11
    }
12

13
    public String getName() { return name; }
14
    public void setName(String name) { this.name = name; }
15
    public int getSalary() { return salary; }
16
    public void setSalary(int salary) { this.salary = salary; }
17

18
    public void teach() {
19
        System.out.println("教学");
20
    }
21

22
    @Override
23
    public boolean equals(Object o) {
24
        if (o == null || getClass() != o.getClass()) return false;
25
        Teacher teacher = (Teacher) o;
26
        return salary == teacher.salary && Objects.equals(name, teacher.name);
27
    }
28

29
    @Override
30
    public int hashCode() {
31
        return Objects.hash(name, salary);
32
    }
33

34
    @Override
35
    public String toString() {
36
        return "Teacher{" +
37
                "name='" + name + '\'' +
38
                ", salary=" + salary +
39
                '}';
40
    }
41
}

代码演示 —— 测试类 reflectTest2（反射 + 配置文件）：

1
public class reflectTest2 {
2
    static void main() throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
3
        /* 反射可以跟配置文件结合的方式，动态创建对象，并调用方法 */
4
        // 创建对象获取配置文件的信息
5
        Properties prop = new Properties();
6
        FileInputStream fis = new FileInputStream("Day35\\prop.properties");
7
        prop.load(fis);
8
        fis.close();
9

10
        // 获取全类名跟方法名
11
        String string1 = (String) prop.get("classname");
12
        String string2 = (String) prop.get("method");
13

14
        // 获取这个对象的字节码文件对象
15
        Class clazz = Class.forName(string1);
16

17
        // 获取构造方法
18
        Constructor declaredConstructor = clazz.getDeclaredConstructor();
19

20
        // 创建对象
21
        Object o = declaredConstructor.newInstance();
22

23
        // 获取方法
24
        Method declaredMethod = clazz.getDeclaredMethod(string2);
25

26
        // 调用方法
27
        declaredMethod.invoke(o);
28
    }
29
}

换一个类跑跑看

只要把 prop.properties 里的 classname 和 method 改一下（比如改成 Student / study），不用改一行 Java 代码，就能创建并调用另一个类的方法。这就是「动态」二字的威力，也是 Spring 等框架「配置驱动」的基础。

✅ 总结一下#

到这里，Java 反射的主线知识就都串完了。最后这趟旅程再捋一遍：

一图流回顾#

每章一句话#

🔍 什么是反射：运行状态里把类当对象研究，无视修饰符、能结合配置文件
🎯 拿 Class 三种方式：forName、类名.class、对象.getClass()——同一个类拿到的是同一个对象
🧱 构造方法：get* 抓、newInstance 建；私有要先 setAccessible(true)
📦 成员变量：get* 抓、set/get 取值赋值；操作对象要先有对象，私有先取消校验
⚙️ 成员方法：get* 抓、invoke(obj,args) 跑；重载要靠形参类型区分
💾 存对象：通过 getDeclaredFields + get 把字段名和值写入文件
🔧 反射 + 配置：从配置文件读类名/方法名，动态创建并调用，改配置不改代码

高频易错点#

写反射时反复检查这几条

私有成员（构造/字段/方法）操作前必须 setAccessible(true)，否则抛异常
getField / getMethod 只能拿 public 的；要拿私有用 getDeclaredField / getDeclaredMethod
同一个类的 Class 对象全局唯一，用 == 比较是 true
getMethod / getDeclaredMethod 取重载方法时，第二个参数要写形参的类型，否则找不到
getFields 包含继承来的 public 成员，getDeclaredFields 只含本类声明的
invoke(obj, args) 第一个参数是对象；值是 static 字段 / 方法时传 null 即可

结尾

感谢看到这里喵~ 反射一开始很抽象，但把代码跑一遍、观察 Class / Constructor / Field / Method 到底打印出来什么，就通了。它不常用，但一旦到框架底层，你就知道它在干什么了。有任何写错或能优化代码的地方，欢迎一起交流进步喵！🪞💪

音乐

音乐

📖 本文导读#

🔍 什么是反射？#

🎯 获取字节码文件对象的三种方式#

🧬 字节码文件和字节码文件对象#

🧱 获取构造方法并创建对象#

📦 获取成员变量并获取值和修改值#

⚙️ 获取成员方法并运行#

💾 利用反射保存对象中的信息#

🔧 反射和配置文件结合动态获取#

✅ 总结一下#

一图流回顾#

每章一句话#

高频易错点#

文章分享

评论区

音乐

Java 反射 学习总结（附代码示例）🪞

📖 本文导读#

🔍 什么是反射？#

🎯 获取字节码文件对象的三种方式#

🧬 字节码文件和字节码文件对象#

🧱 获取构造方法并创建对象#

📦 获取成员变量并获取值和修改值#

⚙️ 获取成员方法并运行#

💾 利用反射保存对象中的信息#

🔧 反射和配置文件结合动态获取#

✅ 总结一下#

一图流回顾#

每章一句话#

高频易错点#

文章分享

评论区

Java 反射学习总结（附代码示例）🪞