|
|
@@ -1,6 +1,6 @@
|
|
|
-# 2026-08-13 反射 Field 字段反射练习（课堂练习用）
|
|
|
+# 2026-08-13 反射 Field 字段反射与 Method 方法反射练习（课堂练习用）
|
|
|
|
|
|
-> **说明**：练习今日新学知识点——**反射 Field（属性/字段/变量）**（Demo01：Class 类获取 Field 对象的 4 个 API——getFields / getField / getDeclaredFields / getDeclaredField、Field 类的常用方法——get() 读取 / set() 赋值 / setAccessible(true) 暴力反射 / getType() 类型 / getName() 属性名 / getModifiers() 修饰符、Modifier.toString 解析修饰符、getDeclaredFields 遍历输出全部字段的修饰符/类型/属性名、getField + get/set 读取修改 public 属性、getDeclaredField + setAccessible(true) 暴力反射读取修改 private 属性、操作静态属性 get/set 对象参数传 null、反射赋值与普通访问是同一份数据、ORM 框架用 Field.set() 把数据库数据映射到 Java 类的底层原理）。练习一写通用工具遍历打印任意类的全部字段；练习二读取/修改 public 字段；练习三暴力反射读取/修改 private 字段；练习四操作静态字段 + 模拟 ORM 框架把"数据库一行记录"映射成 Java 对象（综合实战）。
|
|
|
+> **说明**：练习今日新学知识点——**反射 Field（属性/字段/变量）**（Demo01：Class 类获取 Field 对象的 4 个 API——getFields / getField / getDeclaredFields / getDeclaredField、Field 类的常用方法——get() 读取 / set() 赋值 / setAccessible(true) 暴力反射 / getType() 类型 / getName() 属性名 / getModifiers() 修饰符、Modifier.toString 解析修饰符、getDeclaredFields 遍历输出全部字段的修饰符/类型/属性名、getField + get/set 读取修改 public 属性、getDeclaredField + setAccessible(true) 暴力反射读取修改 private 属性、操作静态属性 get/set 对象参数传 null、反射赋值与普通访问是同一份数据、ORM 框架用 Field.set() 把数据库数据映射到 Java 类的底层原理）+ **反射 Method（方法）**（Demo02：Class 类获取 Method 对象的 4 个 API——getMethods / getMethod / getDeclaredMethods / getDeclaredMethod、重载方法必须传参数类型区分、Method 类的常用方法——invoke 调用 / setAccessible(true) 暴力反射 / getReturnType / getParameterTypes / getModifiers、invoke 四种调用规律——实例方法传对象 / 静态方法传 null / void 返回 null / private 先暴力反射、动态代理 / 测试框架 / 注解解释器的基础）。**练习一~四**：Field 字段反射——通用工具遍历打印全部字段；读取/修改 public 字段；暴力反射读取/修改 private 字段；操作静态字段 + 模拟 ORM 映射（综合实战）。**练习五~八**：Method 方法反射——通用工具遍历打印全部方法；反射调用实例方法（无参/带参/重载）；暴力反射调用私有方法与静态方法；模拟测试框架反射三件套综合实战。
|
|
|
|
|
|
---
|
|
|
|
|
|
@@ -332,6 +332,311 @@ phone = 13800000000
|
|
|
|
|
|
---
|
|
|
|
|
|
+## 练习五：通用工具 —— 遍历打印任意类的所有方法
|
|
|
+
|
|
|
+**难度**：⭐⭐⭐
|
|
|
+**知识点**：`getMethods()`（所有 public 方法，含父类/接口继承如 toString/hashCode）、`getDeclaredMethods()`（本类全部含 private，不含父类/接口）、`method.getParameterTypes()` 参数类型数组 + Stream 流映射、`method.getReturnType()` 返回值类型、`method.getName()` 方法名
|
|
|
+
|
|
|
+**场景描述**：课堂 Demo02 演示① 遍历打印了 Student 的所有方法。本练习把"打印一个类的所有方法"封装成**通用工具方法**——分别打印 **public 方法（含父类 Object 继承的 toString 等）** 和 **本类全部方法（含 private 的 read/write）**，输出格式：`方法名(参数类型列表) 返回值=xxx`。对 Student 调用，观察 `getMethods()` 里哪些是 Object 继承来的（toString/hashCode/equals/getClass），`getDeclaredMethods()` 里多出哪些私有方法（read/write）。
|
|
|
+
|
|
|
+### 案例需求
|
|
|
+
|
|
|
+写两个通用方法：`printPublicMethods(Class<?> clazz)` 打印所有 public 方法（含继承）、`printDeclaredMethods(Class<?> clazz)` 打印本类全部方法（含 private），对 Student.class 调用并对比差异。
|
|
|
+
|
|
|
+### 实现步骤
|
|
|
+
|
|
|
+1. 定义 `printPublicMethods(Class<?> clazz)`：`clazz.getMethods()` 遍历所有 public 方法
|
|
|
+2. 每个方法：`getName()` 方法名 + `getParameterTypes()` 参数类型数组（`Arrays.stream(...)` 用 Stream 流映射成 `List<String>` 简单名）+ `getReturnType().getSimpleName()` 返回值类型
|
|
|
+3. 定义 `printDeclaredMethods(Class<?> clazz)`：`clazz.getDeclaredMethods()` 遍历本类全部方法（含 private），同样的打印格式
|
|
|
+4. main 里用 `Student.class` 分别调用，对比两组输出差异
|
|
|
+5. 数一数 `getMethods()` 里有多少方法是 Object 继承来的（toString/hashCode/equals/getClass/wait/notify/notifyAll）
|
|
|
+
|
|
|
+### 代码框架
|
|
|
+
|
|
|
+```java
|
|
|
+package course;
|
|
|
+
|
|
|
+import java.lang.reflect.Method;
|
|
|
+import java.util.Arrays;
|
|
|
+import java.util.List;
|
|
|
+import java.util.stream.Collectors;
|
|
|
+
|
|
|
+public class MethodPrintUtilTest {
|
|
|
+ public static void main(String[] args) {
|
|
|
+ // 1. 打印 Student 的所有 public 方法（含父类 Object 继承的 toString 等）
|
|
|
+ // 2. 打印 Student 的本类全部方法（含 private 的 read/write）
|
|
|
+ }
|
|
|
+
|
|
|
+ // 通用工具：打印任意类 clazz 的所有 public 方法（方法名(参数类型列表) 返回值=xxx）
|
|
|
+ public static void printPublicMethods(Class<?> clazz) {
|
|
|
+ // getMethods() 遍历
|
|
|
+ // getParameterTypes() → Arrays.stream + map(getSimpleName) + collect(List)
|
|
|
+ // getName() / getReturnType().getSimpleName() 拼接打印
|
|
|
+ }
|
|
|
+
|
|
|
+ // 通用工具：打印任意类 clazz 的本类全部方法（含 private）
|
|
|
+ public static void printDeclaredMethods(Class<?> clazz) {
|
|
|
+ // getDeclaredMethods() 遍历，同样的打印格式
|
|
|
+ }
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+**输出示例**：
|
|
|
+```
|
|
|
+========Student 的 public 方法（含父类/接口继承）========
|
|
|
+getId([]) 返回值=Integer
|
|
|
+setId([Integer]) 返回值=void
|
|
|
+getName([]) 返回值=String
|
|
|
+setName([String]) 返回值=void
|
|
|
+study([]) 返回值=void
|
|
|
+toString([]) 返回值=String ← Object 继承来的
|
|
|
+hashCode([]) 返回值=int ← Object 继承来的
|
|
|
+equals([Object]) 返回值=boolean ← Object 继承来的
|
|
|
+getClass([]) 返回值=Class ← Object 继承来的
|
|
|
+...
|
|
|
+========Student 的本类全部方法（含 private）========
|
|
|
+setName([String]) 返回值=void
|
|
|
+read([]) 返回值=void ← private 方法（getMethods 里看不到）
|
|
|
+write([]) 返回值=void ← private static 方法
|
|
|
+study([]) 返回值=void
|
|
|
+...
|
|
|
+```
|
|
|
+
|
|
|
+**选做加分**：
|
|
|
+- 打印方法个数：`getMethods().length` vs `getDeclaredMethods().length` 对比（public 含继承的更多）
|
|
|
+- 用 `method.getModifiers()` + `Modifier.toString()` 打印每个方法的**修饰符**（public/private/static）
|
|
|
+- 统计 public 方法里哪些是 Object 继承来的——手动挑出 toString/hashCode/equals/getClass/wait/notify/notifyAll，数一数有几个
|
|
|
+
|
|
|
+**思考题**：
|
|
|
+1. `getMethods()` 和 `getDeclaredMethods()` 有什么区别？（提示：含 Declared 的本类全部含 private、不含父类/接口；不含 Declared 的 public 含父类/接口继承——口诀与 Field/Constructor 一致）
|
|
|
+2. 为什么 `getMethods()` 能看到 `toString` 而 `getDeclaredMethods()` 看不到？（提示：toString 是父类 Object 的方法，Declared 只拿本类声明）
|
|
|
+3. `getParameterTypes()` 返回的是什么类型？为什么要用 Stream 流转成字符串？（提示：返回 `Class<?>[]`，直接打印是 `[class java.lang.String]`，映射成简单名更易读）
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+## 练习六：反射调用实例方法 —— getMethod + invoke（无参/带参/重载）
|
|
|
+
|
|
|
+**难度**：⭐⭐⭐⭐
|
|
|
+**知识点**：`getMethod("方法名")` 获取无参方法、`getMethod("方法名", 参数类型...)` 获取带参方法（**重载必须指明参数类型**，不写/写错抛 NoSuchMethodException）、`method.invoke(对象)` 调用无参方法、`invoke(对象, 参数...)` 传参调用、**void 方法 invoke 返回 null**、invoke 返回值强转
|
|
|
+
|
|
|
+**场景描述**：课堂 Demo02 演示② 用 `getMethod("getName")` + `invoke(s)` 调用了无参方法，用 `getMethod("setName", String.class)` + `invoke(s, "李四")` 调用了带参方法。本练习把"调用方法"封装成**通用工具 `invokeMethod(Object obj, String methodName, Object... args)`**——不写死方法名，通过参数反射调用任意 public 实例方法；再用它调用 getName（无参有返回值）和 setName（带参 void）验证，并体会 **void 方法 invoke 返回 null**。
|
|
|
+
|
|
|
+### 案例需求
|
|
|
+
|
|
|
+封装通用方法反射调用工具，用它调用 Student 的 getName()（无参有返回值）和 setName(String)（带参 void），并验证 void 方法的 invoke 返回值。
|
|
|
+
|
|
|
+### 实现步骤
|
|
|
+
|
|
|
+1. 创建 Student 对象（六参构造，name="张三"）
|
|
|
+2. `clazz.getMethod("getName")` 获取无参方法 → `invoke(s)` 调用，**返回值强转 String** 打印
|
|
|
+3. `clazz.getMethod("setName", String.class)` 获取带参方法（**重载必须传参数类型**）→ `invoke(s, "李四")` 调用（**void 方法不接收返回值**）
|
|
|
+4. 用 `s.getName()` 普通访问验证反射 setter 调用生效
|
|
|
+5. 封装通用方法 `invokeMethod(Object obj, String methodName, Object... args)`：根据 args 动态计算参数类型数组 → `getMethod` → `invoke(obj, args)`
|
|
|
+6. 打印 `invokeMethod(s, "setName", "王五")` 的返回值——观察 **void 方法返回 null**
|
|
|
+
|
|
|
+### 代码框架
|
|
|
+
|
|
|
+```java
|
|
|
+package course;
|
|
|
+
|
|
|
+import java.lang.reflect.Method;
|
|
|
+
|
|
|
+public class MethodInvokeTest {
|
|
|
+ public static void main(String[] args) throws Exception {
|
|
|
+ // 1. 创建 Student 对象（六参构造 name="张三"）
|
|
|
+ // 2. 反射调用 getName() 无参方法，接收返回值强转打印
|
|
|
+ // 3. 反射调用 setName(String) 带参方法（void 不接收返回值）
|
|
|
+ // 4. 用 s.getName() 普通访问验证反射 setter 生效
|
|
|
+ // 5. 用封装好的 invokeMethod 工具再调用 setName
|
|
|
+ // 6. 打印 invokeMethod(s, "setName", "王五") 的返回值 → null（void 方法）
|
|
|
+ }
|
|
|
+
|
|
|
+ // 通用工具：反射调用对象 obj 的 public 方法 methodName，参数 args，返回方法执行结果
|
|
|
+ public static Object invokeMethod(Object obj, String methodName, Object... args) throws Exception {
|
|
|
+ // 1. 根据 args 动态计算参数类型数组（每个参数.getClass()）
|
|
|
+ // 2. getMethod(methodName, 参数类型...) 获取方法
|
|
|
+ // 3. method.invoke(obj, args) 调用并返回结果
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+**输出示例**：
|
|
|
+```
|
|
|
+反射调用 getName()：张三
|
|
|
+反射调用 setName("李四") 后：李四
|
|
|
+通用工具调用 setName("王五") 后：王五
|
|
|
+void 方法 invoke 返回值：null
|
|
|
+```
|
|
|
+
|
|
|
+**选做加分**：
|
|
|
+- **重载实验**：给 Student 重载一个 `setName(String, Integer)` 方法，用 invokeMethod 分别调用两个重载版本——体会"重载方法必须传参数类型区分"
|
|
|
+- 用 `getMethod("setName")`（不写参数类型）尝试获取，运行观察抛 **NoSuchMethodException**——验证"重载方法不指明参数类型找不到"
|
|
|
+- **参数类型不匹配实验**：调用 `invokeMethod(s, "setAge", "abc")`（age 是 Integer，传 String），观察 invoke 时抛 **IllegalArgumentException**（参数类型不匹配）
|
|
|
+
|
|
|
+**思考题**：
|
|
|
+1. `invoke` 的第一个参数是什么？为什么调用实例方法必须传对象？（提示：实例方法属于某个对象，必须指明"哪个对象的方法"）
|
|
|
+2. **void 方法**调用 `invoke` 返回什么？有返回值的方法怎么拿结果？（提示：void 返回 null；有返回值返回 Object，可强转成目标类型）
|
|
|
+3. **重载方法**为什么 `getMethod` 必须传参数类型？（提示：方法名相同、参数列表不同，`String.class` 用来区分是哪个重载版本）
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+## 练习七：暴力反射调用私有方法与静态方法 —— getDeclaredMethod + setAccessible(true) + invoke(null)
|
|
|
+
|
|
|
+**难度**：⭐⭐⭐⭐
|
|
|
+**知识点**：`getDeclaredMethod("方法名")` 获取私有方法、`setAccessible(true)` 暴力反射、`invoke(对象)` 调用私有实例方法、**`invoke(null)` 调用静态方法**（静态方法 invoke 传 null，与 Field 操作静态属性传 null 同一规律）、不区分权限的通用方法调用工具
|
|
|
+
|
|
|
+**场景描述**：课堂 Demo02 演示③④ 调用了 Student 的私有方法 `read()`（实例方法）和 `write()`（静态方法）。本练习写**不区分权限**的通用工具 `invokeAnyMethod(Object obj, String methodName, Object... args)`——内部流程 `getDeclaredMethod → setAccessible(true) → invoke`，用它调用 private read()（**实例方法 invoke 传对象 s**）和 private static write()（**静态方法 invoke 传 null**）——完整体会 **invoke 四种调用规律**中的"实例方法传对象、静态方法传 null、私有方法先暴力反射"。
|
|
|
+
|
|
|
+### 案例需求
|
|
|
+
|
|
|
+写通用工具能调用任意权限方法，用它调用 Student 的 private read()（实例方法）和 private static write()（静态方法），并做暴力反射对比实验。
|
|
|
+
|
|
|
+### 实现步骤
|
|
|
+
|
|
|
+1. 创建 Student 对象，反射调用 setName("张三")（复用练习六的工具）
|
|
|
+2. `clazz.getDeclaredMethod("read")` 获取私有实例方法 → `setAccessible(true)` → `invoke(s)` 调用（**传对象 s**）
|
|
|
+3. `clazz.getDeclaredMethod("write")` 获取私有静态方法 → `setAccessible(true)` → `invoke(null)` 调用（**传 null**）
|
|
|
+4. 封装通用工具 `invokeAnyMethod(Object obj, String methodName, Object... args)`：`getDeclaredMethod` + `setAccessible(true)` + `invoke(obj, args)`
|
|
|
+5. 用工具调用 read（obj 传 s）、write（obj 传 null）验证
|
|
|
+6. **对比实验**：把工具里的 `setAccessible(true)` 注释掉，运行观察异常
|
|
|
+
|
|
|
+### 代码框架
|
|
|
+
|
|
|
+```java
|
|
|
+package course;
|
|
|
+
|
|
|
+import java.lang.reflect.Method;
|
|
|
+
|
|
|
+public class MethodPrivateTest {
|
|
|
+ public static void main(String[] args) throws Exception {
|
|
|
+ // 1. 创建 Student 对象，反射调用 setName("张三")（复用练习六工具）
|
|
|
+ // 2. 暴力反射调用私有实例方法 read()（invoke 传对象 s）
|
|
|
+ // 3. 暴力反射调用私有静态方法 write()（invoke 传 null）
|
|
|
+ // 4. 用封装好的 invokeAnyMethod 工具调用 read（obj 传 s）/ write（obj 传 null）
|
|
|
+ }
|
|
|
+
|
|
|
+ // 通用工具：反射调用任意权限方法（getDeclaredMethod + setAccessible + invoke）
|
|
|
+ public static Object invokeAnyMethod(Object obj, String methodName, Object... args) throws Exception {
|
|
|
+ // 1. 计算参数类型数组
|
|
|
+ // 2. getDeclaredMethod(methodName, 参数类型...) 获取方法（含 private）
|
|
|
+ // 3. setAccessible(true) 暴力反射放开权限
|
|
|
+ // 4. invoke(obj, args) 调用并返回结果
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+**输出示例**：
|
|
|
+```
|
|
|
+张三读....... ← 暴力反射调用 private read()（实例方法，invoke 传对象 s，name 已是"张三"）
|
|
|
+静态方法...写............... ← 暴力反射调用 private static write()（静态方法，invoke 传 null）
|
|
|
+张三读....... ← 通用工具调用 read()（obj 传 s）
|
|
|
+静态方法...写............... ← 通用工具调用 write()（obj 传 null）
|
|
|
+```
|
|
|
+
|
|
|
+**选做加分**：
|
|
|
+- **对比实验（必做）**：把 `invokeAnyMethod` 里的 `setAccessible(true)` 注释掉，运行观察抛 **IllegalAccessException**——体会"私有方法不放开权限无法 invoke"
|
|
|
+- 用 `getMethod("read")`（不带 Declared）尝试获取私有方法，运行观察抛 **NoSuchMethodException**——验证"getMethod 只能拿 public"的口诀
|
|
|
+- **静态方法传对象实验**：write() 是静态方法，invoke 第一参数传对象 s 试试（`invoke(s)`），观察是否也能执行——体会静态方法不依赖对象，传什么都会被忽略
|
|
|
+- 用 `method.getModifiers()` + `Modifier.toString()` 打印 read/write 的修饰符，观察 `private` / `private static`
|
|
|
+
|
|
|
+**思考题**：
|
|
|
+1. 为什么私有方法必须 `setAccessible(true)` 才能 invoke？（提示：Java 访问权限检查，不放开抛 IllegalAccessException——暴力反射）
|
|
|
+2. 静态方法 invoke 为什么传 **null**？与 Field 操作静态属性传 null 是什么关系？（提示：静态成员属于整个类、不属于任何对象——本课核心规律统一）
|
|
|
+3. `getDeclaredMethod` 与 `getMethod` 的区别？调用私有方法为什么必须用前者？（提示：口诀"含 Declared 的能拿私有"）
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+## 练习八：综合实战 —— 模拟测试框架（JUnit 简化版）：反射三件套扫描并调用私有测试方法
|
|
|
+
|
|
|
+**难度**：⭐⭐⭐⭐⭐
|
|
|
+**知识点**：反射三件套全家桶（Constructor 创建对象 + Field 给字段赋值 + Method 调用方法）、`getDeclaredMethods()` 遍历扫描方法、私有方法暴力反射、**`InvocationTargetException`**（invoke 包装被调方法内部异常，`getCause()` 取真实异常）、`method.invoke` 返回值、`startsWith("test")` 过滤测试方法
|
|
|
+
|
|
|
+**场景描述**：这是"Method 是测试框架、注解解释器的基础"的完整落地——**JUnit 测试框架的底层原理**：扫描一个类的所有方法，找出测试方法，反射创建对象后逐个调用。本练习给 Student 添加几个 **private 测试方法**（testAdd / testHello / testFail），写一个"**迷你测试框架** `MiniJUnitTest`"：
|
|
|
+1. **反射创建被测对象**（Constructor）
|
|
|
+2. **getDeclaredMethods() 扫描**所有方法，找出名字以 `test` 开头的方法
|
|
|
+3. 每个测试方法 **setAccessible(true) + invoke(对象)** 执行（Method）
|
|
|
+4. 方法内部抛异常 → invoke 抛 **InvocationTargetException**，`getCause()` 打印真实异常并统计"测试失败"
|
|
|
+
|
|
|
+——完整走一遍"反射三件套（创建对象/调方法）+ 暴力反射 + 异常处理"的**框架级流程**。
|
|
|
+
|
|
|
+### 案例需求
|
|
|
+
|
|
|
+写一个迷你测试框架：反射创建 Student 对象，扫描所有以 test 开头的私有方法并暴力反射调用，统计测试通过/失败个数（方法抛异常算失败，用 InvocationTargetException.getCause() 打印原因）。
|
|
|
+
|
|
|
+### 实现步骤
|
|
|
+
|
|
|
+1. 给 Student 增加 3 个 private 测试方法：`testAdd()`（正常通过）、`testHello()`（正常通过）、`testFail()`（故意抛异常）
|
|
|
+2. `Student.class.getConstructor().newInstance()` 反射创建被测对象
|
|
|
+3. `clazz.getDeclaredMethods()` 遍历 Student 全部方法
|
|
|
+4. 用 `method.getName().startsWith("test")` 找出测试方法（过滤掉 read/write/study/getXxx 等）
|
|
|
+5. 对每个测试方法：`setAccessible(true)` + `invoke(obj)` 执行
|
|
|
+6. **try-catch 捕获 `InvocationTargetException`** → `getCause()` 打印真实异常信息
|
|
|
+7. 统计"测试通过 / 测试失败"个数
|
|
|
+
|
|
|
+### 代码框架
|
|
|
+
|
|
|
+```java
|
|
|
+package course;
|
|
|
+
|
|
|
+import java.lang.reflect.InvocationTargetException;
|
|
|
+import java.lang.reflect.Method;
|
|
|
+
|
|
|
+public class MiniJUnitTest {
|
|
|
+ public static void main(String[] args) throws Exception {
|
|
|
+ // 1. 反射创建被测 Student 对象（getConstructor().newInstance()）
|
|
|
+ // 2. getDeclaredMethods() 遍历 Student 全部方法
|
|
|
+ // 3. 方法名以 "test" 开头 → 认定为测试方法
|
|
|
+ // 4. 对每个测试方法：setAccessible(true) + invoke(obj) 执行
|
|
|
+ // 5. 捕获 InvocationTargetException → getCause() 打印真实异常
|
|
|
+ // 6. 统计通过/失败个数
|
|
|
+ }
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+**Student 补充测试方法**（在被测类 course/Student.java 中补充）：
|
|
|
+
|
|
|
+```java
|
|
|
+// 来源：course/Student.java（模拟被测类的测试方法）
|
|
|
+private void testAdd() {
|
|
|
+ System.out.println("测试：加法计算");
|
|
|
+ int a = 1 + 1;
|
|
|
+ if (a != 2) throw new RuntimeException("加法计算错误");
|
|
|
+}
|
|
|
+private void testHello() {
|
|
|
+ System.out.println("测试：打招呼 " + this.name);
|
|
|
+}
|
|
|
+private void testFail() {
|
|
|
+ throw new RuntimeException("故意失败的方法");
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+**输出示例**：
|
|
|
+```
|
|
|
+找到测试方法：testAdd
|
|
|
+测试通过：testAdd
|
|
|
+找到测试方法：testHello
|
|
|
+测试通过：testHello
|
|
|
+找到测试方法：testFail
|
|
|
+测试失败：testFail，原因：故意失败的方法
|
|
|
+测试通过 2 个，失败 1 个
|
|
|
+```
|
|
|
+
|
|
|
+**选做加分**：
|
|
|
+- **getMethods() 扫描对比**：把测试方法改成 public、改用 `getMethods()` 扫描——观察 toString/hashCode 等 Object 继承方法也会被扫到，思考怎么过滤掉（提示：`!method.getName().equals("toString")` 或判断 `getDeclaringClass()`）
|
|
|
+- **给测试方法传参**：写一个带参数的测试方法 `testAdd(int a, int b)`，用 `invoke(obj, 3, 5)` 传参调用——体会"参数如何通过 invoke 传入"
|
|
|
+- **返回值处理**：让 test 方法返回 `boolean`（true 通过 false 失败），`invoke` 返回 Object 强转 boolean 判断——体会"invoke 返回方法执行结果"
|
|
|
+- **注解模拟（进阶）**：定义自定义注解 `@MyTest`，扫描时用 `method.isAnnotationPresent(MyTest.class)` 只调用带注解的方法——这就是 JUnit 的 `@Test` 注解底层原理
|
|
|
+
|
|
|
+**思考题**：
|
|
|
+1. 测试框架为什么要用**反射扫描方法**，而不是直接 `obj.testAdd()` 调用？（提示：框架在编译期不知道被测类有哪些测试方法——运行期动态扫描，这就是"为什么需要反射"）
|
|
|
+2. 方法内部抛异常时，为什么 `invoke` 抛的是 **InvocationTargetException** 而不是原异常？（提示：invoke 把被调方法内部异常**包装**了一层，需要 `getCause()` 取真正的异常对象）
|
|
|
+3. 这个"迷你测试框架"和真实的 JUnit 有什么相似之处？（提示：JUnit 也是扫描类的方法 + 反射创建对象 + 反射调用；JUnit 用 @Test 注解标记测试方法、本练习用 test 前缀过滤）
|
|
|
+4. 如果把测试方法改名成非 test 开头（如 study），扫描时会被执行吗？为什么？（提示：`startsWith("test")` 过滤——只有 test 开头的方法才会被认定为测试方法）
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
# 涵盖知识点总览
|
|
|
|
|
|
| 知识点 | 说明 |
|
|
|
@@ -353,4 +658,18 @@ phone = 13800000000
|
|
|
| **通用映射 mapToObject** | 反射创建空对象 + `getDeclaredFields` 遍历 + 字段名匹配 row 的 key + `setAccessible(true)` + `field.set`——模拟数据库行 → Java 对象 |
|
|
|
| **反射的通用性** | 工具方法传入任意 Class/对象都能工作（打印任意类字段、读写任意对象属性）——不写死具体类，配置驱动 + 解耦 |
|
|
|
| **反射的注意事项** | 日常业务尽量不用：破坏封装性、效率低 3~100 倍；学习反射为理解框架底层源码（ORM/IOC） |
|
|
|
+| `getMethods()` | 返回**所有 public 方法**数组，**包括父类/接口继承的**（如 toString/hashCode/getClass） |
|
|
|
+| `getMethod(name, parameterTypes)` | 返回**指定的单个 public 方法**；**重载方法必须传参数类型区分**（如 `getMethod("setName", String.class)`），不写/写错抛 NoSuchMethodException |
|
|
|
+| `getDeclaredMethods()` | 返回**本类所有方法**数组，**包括 private，但不包括父类/接口的方法** |
|
|
|
+| `getDeclaredMethod(name, parameterTypes)` | 返回**指定的单个方法**，**包括 private**——操作私有方法必须用它 |
|
|
|
+| `method.invoke(obj, 参数...)` | **调用方法**，返回方法执行结果（Object 可强转）；实例方法第一参数传对象、**静态方法传 null**、**void 方法返回 null**、**private 先 setAccessible(true)** |
|
|
|
+| `method.setAccessible(true)` | **暴力反射**：临时取消访问权限检查——调用 private 方法必须调用，否则抛 IllegalAccessException |
|
|
|
+| `method.getReturnType()` / `getParameterTypes()` / `getModifiers()` | 获取返回值类型（`getSimpleName()` 得简单名）/ 参数类型数组（Stream 映射简单名）/ 修饰符（Modifier.toString 解析） |
|
|
|
+| **invoke 四种调用规律** | ①实例方法 `invoke(对象,参数...)` 传对象 ②静态方法 `invoke(null,参数...)` 传 null ③void 方法 invoke 返回 null ④private 方法先 setAccessible(true) |
|
|
|
+| **遍历打印方法** | `getMethods()`/`getDeclaredMethods()` 遍历 + `getParameterTypes()` + `getReturnType().getSimpleName()` 输出方法名/参数/返回值——对比含继承 vs 本类全部 |
|
|
|
+| **反射调用 setter/getter** | `getMethod("setName", String.class)` + `invoke(obj, "李四")` 反射调用 setter 赋值（void 不接收返回值）、`getMethod("getName")` + `invoke(obj)` 调用 getter 取返回值——框架 BeanUtils 的底层 |
|
|
|
+| **InvocationTargetException** | invoke 调用方法时被调方法内部抛异常，invoke 会把它**包装成 InvocationTargetException** 抛出——需要 `getCause()` 获取真正的异常 |
|
|
|
+| **模拟测试框架（JUnit 原理）** | `getDeclaredMethods()` 扫描类的方法 → `startsWith("test")` 过滤测试方法 → `setAccessible(true)` + `invoke(obj)` 执行 → 捕获 InvocationTargetException 统计通过/失败——JUnit 扫描 @Test 注解方法的底层套路 |
|
|
|
+| **反射三件套组合** | Constructor（newInstance 创建对象）+ Field（get/set 读写字段）+ Method（invoke 调用方法）——三者组合 = MyBatis 结果映射 / Spring Bean 初始化 / 测试框架执行测试用例的完整底层链路 |
|
|
|
+| **反射 API 的受检异常** | NoSuchFieldException（字段名不存在）/ NoSuchMethodException（方法名或参数类型不匹配）/ IllegalAccessException（private 未放开权限）/ InvocationTargetException（被调方法内部抛异常）/ ClassNotFoundException（类名写错）——必须处理（main 用 throws） |
|
|
|
| **反射 API 的受检异常** | NoSuchFieldException（字段名不存在）/ IllegalAccessException（private 未放开权限）——必须处理（main 用 throws） |
|
WanJL