From 8958a9367e0e29f95d5957a32975fa5df38a2eec Mon Sep 17 00:00:00 2001
From: ZhengShiyi <1980003269@qq.com>
Date: Tue, 28 Apr 2026 17:08:42 +0800
Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4Java=E6=B3=9B=E5=9E=8B?=
 =?UTF-8?q?=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 W8/Cache.java                                 |  64 ++++++
 ...�Žå¦‚何通过å��射获å�–泛型信æ�¯.txt |  84 ++++++++
 W8/Pair.java                                  |  47 +++++
 W8/代�审查报告.md                      | 190 ++++++++++++++++++
 4 files changed, 385 insertions(+)
 create mode 100644 W8/Cache.java
 create mode 100644 W8/Java泛型擦除�如何通过�射获�泛型信�.txt
 create mode 100644 W8/Pair.java
 create mode 100644 W8/代�审查报告.md

diff --git a/W8/Cache.java b/W8/Cache.java
new file mode 100644
index 0000000..ca21d13
--- /dev/null
+++ b/W8/Cache.java
@@ -0,0 +1,64 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Cache<K, V> {
+    // 底层用 HashMap 存储数�
+    private final Map<K, V> cacheMap;
+
+    public Cache() {
+        this.cacheMap = new HashMap<>();
+    }
+
+    // 存入缓存
+    public void put(K key, V value) {
+        cacheMap.put(key, value);
+    }
+
+    // 从缓存获�
+    public V get(K key) {
+        return cacheMap.get(key);
+    }
+
+    // 删除缓存
+    public void remove(K key) {
+        cacheMap.remove(key);
+    }
+
+    // 判断缓存是�包��个 key
+    public boolean containsKey(K key) {
+        return cacheMap.containsKey(key);
+    }
+
+    // 清空缓存
+    public void clear() {
+        cacheMap.clear();
+    }
+
+    // 获�缓存大�
+    public int size() {
+        return cacheMap.size();
+    }
+
+    // 测试主方法
+    public static void main(String[] args) {
+        Cache<String, Integer> studentScoreCache = new Cache<>();
+
+        // 存入数�
+        studentScoreCache.put("张三", 90);
+        studentScoreCache.put("�四", 85);
+        studentScoreCache.put("王五", 95);
+
+        // 查询数�
+        System.out.println("张三的分数：" + studentScoreCache.get("张三"));
+        System.out.println("缓存大�：" + studentScoreCache.size());
+
+        // 删除数�
+        studentScoreCache.remove("�四");
+        System.out.println("删除�四�缓存大�：" + studentScoreCache.size());
+        System.out.println("是�包��四？" + studentScoreCache.containsKey("�四"));
+
+        // 清空缓存
+        studentScoreCache.clear();
+        System.out.println("清空�缓存大�：" + studentScoreCache.size());
+    }
+}
\ No newline at end of file
diff --git a/W8/Java泛型擦除�如何通过�射获�泛型信�.txt b/W8/Java泛型擦除�如何通过�射获�泛型信�.txt
new file mode 100644
index 0000000..8159e3b
--- /dev/null
+++ b/W8/Java泛型擦除�如何通过�射获�泛型信�.txt
@@ -0,0 +1,84 @@
+ 一�Java 泛型擦除的本质
+Java 的泛型是一�编译期语法糖，并�原生支�的语言特性。为了兼容 JDK 1.5 之�没有泛型的代�，编译器会在编译阶段执行类型擦除（Type Erasure）：
+
+1.  擦除泛型�数
+    所有泛型类型�数（如 `<T>`�`<K, V>`）会被替�为它们的上界类型：
+    - 未指定上界时，默认擦除为 `Object`。
+      例如 `List<String>` → 编译��为 `List`，`add` 方法�� `add(Object)`，`get` 方法返回 `Object`。
+    - 指定上界时，擦除为上界类型。
+      例如 `List<? extends Number>` → 编译�擦除为 `List<Number>`。
+
+2.  �入强制类型转�
+    为了��代�在�行时的类型安全，编译器会在读�泛型元素的地方自动�入强制类型转�。
+    例如 `String s = list.get(0);` 编译�会�� `String s = (String) list.get(0);`。
+
+核心结果：
+�行时 JVM �能看到原始类型（如 `List`�`Map`），无法直接感知到 `String`�`Integer` 这类泛型�数信�。
+
+ 二�为什么还能通过�射获�部分泛型信�？
+虽然大部分泛型信�被擦除了，但有一部分结构级别的泛型信�会被编译器刻��留，并写入 `.class` 字节�文件的 `Signature` 属性中。
+
+1. 哪些泛型信�会被�留？
+�有定义在类�接���员���方法签�上的泛型信�会被�留，具体包括：
+- 类/接�的父类/实现接�声明
+  例如 `public class MyList extends ArrayList<String>`，`ArrayList<String>` 这个带泛型的父类信�会被�留。
+- 类中�员��（Field）的泛型类型
+  例如 `private List<Integer> scores;`，`List<Integer>` 的泛型信�会被�留。
+- 方法（Method）的�数类型与返回值类型
+  例如 `public List<String> getNames(List<String> ids)`，�数和返回值的泛型信�会被�留。
+
+ 2. 为什么这些信�会被�留？
+- 为了��编译器的类型检查：IDE 和编译器需�这些信��检查代�的类型安全。
+- 为了支��射 API：JDK 设计了专门的�射接��读�这些信�，��框架（如 Spring�Jackson）能基于泛型�自动化处�。
+- 这些信��存在字节�的 `Signature` 属性中，�会影��行时的兼容性。
+
+ 三�通过�射获�泛型信�的步骤
+
+ 步骤 1：获�目标的�射元数�对象
+根�你�获�的泛型类型，先拿到对应的元数�对象：
+- 获�类/父类的泛型：拿到目标类的 `Class` 对象。
+- 获��员��的泛型：拿到目标��的 `Field` 对象。
+- 获�方法�数/返回值的泛型：拿到目标方法的 `Method` 对象。
+
+ 步骤 2：调用 `getGenericXXX()` 方法获�带泛型的 `Type` 对象
+�射 API �供了专门的方法，�读�字节�中�留的 `Signature` 信�，返回一个 `java.lang.reflect.Type` 对象（它是所有类型的通用接�）：
+- 父类：`Class.getGenericSuperclass()`
+- 实现接�：`Class.getGenericInterfaces()`
+- �员��类型：`Field.getGenericType()`
+- 方法返回值类型：`Method.getGenericReturnType()`
+- 方法�数类型：`Method.getGenericParameterTypes()`
+
+注�：这些方法和普通的 `getSuperclass()`�`getType()` ��，�者返回的是擦除�的原始类型（如 `ArrayList`），而�者返回的是�留了泛型信�的 `Type` 对象。
+
+步骤 3：判断并解� `ParameterizedType`（�数化类型）
+`Type` 是一个空接�，它的一个��实现是 `ParameterizedType`，用�表示带泛型的�数化类型（如 `List<String>`�`Map<K, V>`）。
+
+你需�先判断获�到的 `Type` 是�是 `ParameterizedType` 实例：
+- 如果是，就�以调用它的核心方法 `getActualTypeArguments()`，这个方法会返回一个 `Type[]` 数组，里�就是定义时声明的真实泛型�数。
+- 数组里的�个元素，都对应�原始声明中的泛型�数（如 `List<String>` 会返回一个长度为 1 的数组，元素为 `String`；`Map<K, V>` 会返回长度为 2 的数组，分别为 `K` 和 `V`）。
+
+步骤 4：递归解�嵌套泛型（如 `List<List<String>>`）
+如果泛型本身还是一个�数化类型（如 `List<List<String>>`），`getActualTypeArguments()` 返回的 `Type` �然是一个 `ParameterizedType`，你�以��步骤 3，递归解�嵌套的泛型信�。
+
+ 四���场景下的获�能力对比
+|               场景                |                                                    示例                                       | 能�通过�射获�泛型信�？ |                            原因                         |
+
+| 类继承的父类泛型        | `class A extends B<String>`                                                 | ✅ 能                                          | 信��存在类的 `Signature` 属性中 |
+| 类实现的接�泛型        | `class C implements D<Integer>`                                         | ✅ 能                                         | 信��存在类的 `Signature` 属性中 |
+| �员��的泛型            | `private List<String> list;`                                                     | ✅ 能                                          | 信��存在字段的 `Signature` 属性中 |
+| 方法返回值的泛型        | `public List<String> getList()`                                               | ✅ 能                                          | 信��存在方法的 `Signature` 属性中 |
+| 方法�数的泛型            | `public void setList(List<String> list)`                                  | ✅ 能                                          | 信��存在方法的 `Signature` 属性中 |
+| 方法内局部��的泛型 | `public void test() { List<String> l = new ArrayList<>(); }` | � �能                                      | 局部��的泛型信�编译�完全擦除，无任何�留 |
+| 直接创建的泛型对象     | `new ArrayList<String>()`                                                      | � �能                                      | 仅在编译期有效，�行时没有任何元数� |
+
+五�局�性与注�事项
+1.  �能获�定义时声明的泛型，无法获��行时传入的类型
+    例如 `List<String> list = new ArrayList<>();`，�射无法知� `list` 里存的是 `String`，�能知� `list` 这个��声明时的类型是 `List<String>`。
+2.  无法获�通�符泛型的具体类型
+    例如 `List<? extends Number>`，�射能知�它的上界是 `Number`，但无法知��行时实际传入的具体�类型。
+3.  类型��（如 `<T>`）的解�需�上下文
+    如果是未绑定的类型��（如 `class Box<T>` 中的 `T`），�射�能获�到���，无法知�它的具体类型，除�它被绑定到了具体的类上（如 `class StringBox extends Box<String>`）。
+
+
+ 六�总结
+Java 泛型擦除�，�行时大部分泛型信�会被移除，但类�接���员���方法签�上声明的泛型信�会被�留在字节�的 `Signature` 属性中。通过�射 API 获�这些元数�，将其解�为 `ParameterizedType` 并调用 `getActualTypeArguments()`，��读�对应的泛型信�；而方法内局部��的泛型信�会被完全擦除，无法通过�射获�。
diff --git a/W8/Pair.java b/W8/Pair.java
new file mode 100644
index 0000000..68a30ae
--- /dev/null
+++ b/W8/Pair.java
@@ -0,0 +1,47 @@
+public class Pair<K, V> {
+    private K key;
+    private V value;
+
+    public Pair(K key, V value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    public K getKey() {
+        return key;
+    }
+
+    public void setKey(K key) {
+        this.key = key;
+    }
+
+    public V getValue() {
+        return value;
+    }
+
+    public void setValue(V value) {
+        this.value = value;
+    }
+
+    // swap 方法：交� key 和 value
+    public Pair<V, K> swap() {
+        return new Pair<>(this.value, this.key);
+    }
+
+    @Override
+    public String toString() {
+        return "Pair{" +
+                "key=" + key +
+                ", value=" + value +
+                '}';
+    }
+
+    // 测试主方法
+    public static void main(String[] args) {
+        Pair<String, Integer> pair = new Pair<>("年龄", 20);
+        System.out.println("原对象：" + pair);
+
+        Pair<Integer, String> swapped = pair.swap();
+        System.out.println("交��：" + swapped);
+    }
+}
\ No newline at end of file
diff --git a/W8/代�审查报告.md b/W8/代�审查报告.md
new file mode 100644
index 0000000..9a37f07
--- /dev/null
+++ b/W8/代�审查报告.md
@@ -0,0 +1,190 @@
+# 代�审查报告（Cache<K,V> 泛型缓存类）
+
+### 一�代�整体评价
+
+这段代�整体质�很高，实现了一个基于泛型的键值缓存，功能完整�结构清晰�符� Java 编�规范，完全满足作业�求。
+
+#### 二�代�优点
+
+正确使用泛型 <K,V>泛型定义规范，支�任�类型的键值对，通用性强。
+
+�装性良好使用 private final Map<K,V> 存储数�，外部无法直接修改，��数�安全。
+
+功能完整实现了缓存的核心�作：
+
+添加 put
+
+获� get
+
+删除 remove
+
+判断存在 containsKey
+
+清空 clear
+
+获�大� size
+
+代�简�易读方法命�规范�注释清晰�逻辑直白，符� Java 标准写法。
+
+自带测试方法main 方法�供完整测试用例，�直接�行验�功能。
+
+�赖��基于 HashMap 实现，性能高效，适�缓存场景。
+
+### 三�代�存在的问题
+
+这些�是错误，�是�够规范：
+
+没有对 null �安全处�
+
+�许存入 null 键 / 值
+
+获�时�能返回 null，外部使用容易空指针
+
+→ 建议增加�空校验
+
+线程�安全HashMap 是�线程安全的，多线程环境下会出现数�错误。
+
+没有最大容��制无缓存上�，�断存入会导致内存�用过高。
+
+无过期策略真实缓存都有过期时间，当�代�数�永久�存。
+
+缺少 toString () 方法无法直接打�查看缓存内容，调试�方便。
+
+### 四�改进�的优化代�
+
+import java.util.HashMap;
+
+import java.util.Map;
+
+import java.util.Objects;
+
+
+
+public class Cache<K, V> {
+
+&#x20;   private final Map<K, V> cacheMap;
+
+
+
+&#x20;   public Cache() {
+
+&#x20;       this.cacheMap = new HashMap<>();
+
+&#x20;   }
+
+
+
+&#x20;   // 存入缓存（增加�空判断）
+
+&#x20;   public void put(K key, V value) {
+
+&#x20;       Objects.requireNonNull(key, "键�能为空");
+
+&#x20;       Objects.requireNonNull(value, "值�能为空");
+
+&#x20;       cacheMap.put(key, value);
+
+&#x20;   }
+
+
+
+&#x20;   // 获�缓存
+
+&#x20;   public V get(K key) {
+
+&#x20;       return cacheMap.get(key);
+
+&#x20;   }
+
+
+
+&#x20;   // 删除
+
+&#x20;   public void remove(K key) {
+
+&#x20;       cacheMap.remove(key);
+
+&#x20;   }
+
+
+
+&#x20;   // 是�包�
+
+&#x20;   public boolean containsKey(K key) {
+
+&#x20;       return cacheMap.containsKey(key);
+
+&#x20;   }
+
+
+
+&#x20;   // 清空
+
+&#x20;   public void clear() {
+
+&#x20;       cacheMap.clear();
+
+&#x20;   }
+
+
+
+&#x20;   // 大�
+
+&#x20;   public int size() {
+
+&#x20;       return cacheMap.size();
+
+&#x20;   }
+
+
+
+&#x20;   // 打�缓存内容
+
+&#x20;   @Override
+
+&#x20;   public String toString() {
+
+&#x20;       return "Cache{" + "data=" + cacheMap + '}';
+
+&#x20;   }
+
+
+
+&#x20;   // 测试
+
+&#x20;   public static void main(String\[] args) {
+
+&#x20;       Cache<String, Integer> studentScoreCache = new Cache<>();
+
+
+
+&#x20;       studentScoreCache.put("张三", 90);
+
+&#x20;       studentScoreCache.put("�四", 85);
+
+&#x20;       studentScoreCache.put("王五", 95);
+
+
+
+&#x20;       System.out.println(studentScoreCache);
+
+&#x20;       System.out.println("张三的分数：" + studentScoreCache.get("张三"));
+
+&#x20;       System.out.println("缓存大�：" + studentScoreCache.size());
+
+
+
+&#x20;       studentScoreCache.remove("�四");
+
+&#x20;       System.out.println("删除�四�：" + studentScoreCache);
+
+
+
+&#x20;       studentScoreCache.clear();
+
+&#x20;       System.out.println("清空�缓存大�：" + studentScoreCache.size());
+
+&#x20;   }
+
+}
+