完成泛型缓存类

W8/AI协同.txt

@@ -0,0 +1,59 @@
+ 一、使用 AI 工具解决问题：Java 泛型擦除后如何通过反射获取泛型信息？
+**我向 AI 提出的问题：**
+Java 泛型在编译后会进行类型擦除，为什么还能通过反射获取泛型信息？具体如何实现？
+
+**AI 给出的解答：**
+Java 的泛型在运行时会被擦除，但**类、方法、字段上定义的泛型签名信息会被保留在字节码文件中**，以便编译器和反射 API 使用。
+我们可以通过以下反射 API 获取泛型信息：
+- **ParameterizedType**：表示参数化类型（如 List<String>、Map<K,V>）
+- **getGenericSuperclass()**：获取带泛型的父类
+- **getGenericInterfaces()**：获取带泛型的接口
+- **getGenericReturnType()**：获取带泛型的返回值类型
+
+**AI 提供的示例思路：**
+通过反射获取泛型的实际类型参数，再从中拿到真实类型。
+
+---
+
+## 二、使用 AI 工具审查代码（泛型缓存类 Cache）
+我将自己编写的 **Cache<K, V> 泛型缓存代码**交给 AI 进行审查，AI 给出以下评价与建议：
+
+**AI 代码审查结果：**
+1. **代码结构规范**：泛型定义正确，使用<K,V>实现了通用缓存。
+2. **功能完整**：实现了缓存的存、取、删除、清空、判断存在等功能。
+3. **使用 HashMap 合理**：适合作为缓存底层存储，读写效率高。
+4. **线程安全问题**：当前版本未考虑多线程环境，若在多线程中使用可能出现并发问题。
+5. **无内存管理机制**：不会自动清理过期数据。
+
+**AI 总结：**
+代码满足课程作业要求，泛型使用规范，逻辑正确，可以正常运行。
+
+---
+
+## 三、AI 学习总结（我学到了什么）
+通过本次 AI 协同学习，我掌握了以下内容：
+1. 了解**泛型擦除**并不代表泛型信息完全消失，反射仍可获取。
+2. 学会**ParameterizedType**的作用与使用场景。
+3. 知道如何借助 AI 检查代码错误、优化逻辑。
+4. 加深了对**泛型类、泛型方法、类型安全**的理解。
+5. 明白泛型的意义：让代码更通用、更安全、更易复用。
+
+为什么 Java 泛型不支持基本类型？
+Java 泛型不支持 int、char、boolean、double 等基本类型，核心原因只有 3 点
+1. 泛型底层是 类型擦除
+Java 泛型在编译后会把所有泛型类型变成 Object例如：
+plaintext
+Pair<K,V> → 编译后变成 Pair<Object, Object>
+2. 基本类型 不是 Object 的子类
+int、char、boolean 不属于对象
+它们不能被 Object 接收
+所以泛型无法存储基本类型
+3. 只能用 包装类 代替
+Java 提供了对应的包装类：
+int → Integer
+char → Character
+boolean → Boolean
+double → Double
+这些是对象，继承自 Object，可以被泛型接收。
+
+

W8/代码.txt

@@ -0,0 +1,69 @@
+
+import java.util.HashMap;
+import java.util.Map;
+
+// 整个作业只需要这一个文件！
+
+    // 泛型键值对 Pair
+    static class Pair<K, V> {
+        private K key;
+        private V value;
+
+        public Pair(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        // 交换方法
+        public Pair<V, K> swap() {
+            return new Pair<>(value, key);
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+    }
+
+    // 泛型缓存 Cache
+    static class Cache<K, V> {
+        private Map<K, V> map = new HashMap<>();
+
+        public void put(K key, V value) {
+            map.put(key, value);
+        }
+
+        public V get(K key) {
+            return map.get(key);
+        }
+
+        public void remove(K key) {
+            map.remove(key);
+        }
+
+        public void clear() {
+            map.clear();
+        }
+
+        public boolean containsKey(K key) {
+            return map.containsKey(key);
+        }
+    }
+
+    // 主程序运行
+    public static void main(String[] args) {
+        // 测试 void main(String[] args) {
+        // 测试 Pair
+        Pair<String, Integer> pair = new Pair<>("成绩", 95);
+        Pair<Integer, String> swapped = pair.swap();
+        System.out.println("交换前：" + pair.getKey() + " " + pair.getValue());
+        System.out.println("交换后：" + swapped.getKey() + " " + swapped.getValue());
+
+        // 测试 Cache
+        Cache<String, String> cache = new Cache<>();
+        cache.put("姓名", "张三");
+        System.out.println("获取缓存：" + cache.get("姓名"));
+    }