w8

w3/Employee.java

@@ -1,4 +1,4 @@
-package w3;
+
 
 public class Employee {
         // 静态变量：公司名称

w3/TestEmployee.java

@@ -1,4 +1,3 @@
-package w3;
 
 public class TestEmployee {
         public static void main(String[] args) {

w7/AI协助记录

@@ -28,3 +28,4 @@ try ( 创建需要自动关闭的资源对象 ) {
 } catch (异常) {
     // 处理异常
 }
+三：scores.txt文件放在w7文件夹外，不然会读取失败

w7/ScoreAverage.java

@@ -1,4 +1,4 @@
-package w7;
+
 
 import java.io.BufferedReader;
 import java.io.FileReader;

w8/AI协助记录

@@ -0,0 +1,35 @@
+AI协助记录
+一：Java 泛型擦除后，如何通过反射获取泛型信息？
+核心原理
+Java 泛型采用类型擦除，运行时会擦除泛型信息（如 List<String> 变成 List），但以下场景会保留泛型信息：
+1.类 / 接口上声明的泛型（如 class MyList implements List<String>）
+2.方法的返回值、参数上的泛型（如 public List<String> getNames()）
+3.字段上的泛型（如 private List<String> names;）
+二：思考题：为什么 Java 泛型不支持基本类型？
+核心原因有 3 个：
+1.泛型擦除机制
+泛型擦除后，所有泛型类型都会被擦除为 Object（或其上界类型）。而基本类型（如 int、char）不是 Object 的子类，无法直接赋值给 Object 类型变量，因此无法直接参与泛型。
+2.自动装箱 / 拆箱的补充
+Java 提供了基本类型的包装类（如 Integer、Character），配合自动装箱 / 拆箱，间接实现了 “泛型支持基本类型” 的效果。例如 List<Integer> 本质上是 List<Object>，存入 int 时会自动装箱为 Integer，取出时自动拆箱为 int。
+3.历史与设计兼容性
+Java 早期没有泛型，基本类型是为了性能设计的独立体系，和对象体系不兼容。如果让泛型直接支持基本类型，需要修改 JVM 底层和语言规范，成本极高，因此采用了 “擦除 + 包装类” 的折中方案。
+三：AI审查代码
+1.优点
+（1）泛型使用规范
+PairInner<K,V>、Cache<K,V> 泛型定义正确
+类型安全，无强制转换，无警告
+（2）swap 方法设计极佳
+不修改原对象，返回新对象
+自动反转泛型类型 <K,V> → <V,K>
+无风险、无警告、Java 标准写法
+（3）Cache 类功能完整
+put /get/remove /clear/containsKey 齐全
+（4）代码结构清晰
+内部类 + 主方法，一个文件完成作业要求
+2.缺点
+（1） 缺少 toString ()
+打印对象时不能直接 System.out.println(pair)必须手动 getKey() + getValue()
+（2）缺少 final 修饰（可优化）
+成员变量 key、value 可以加 final，变成不可变对象，更安全。
+（3） Cache 缺少 size () 方法
+作业一般要求缓存大小获取方法，加上更完美。

w8/Pair.java

@@ -0,0 +1,70 @@
+package w8;  
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Pair {
+
+    // 泛型键值对 Pair
+    static class PairInner<K, V> {
+        private K key;
+        private V value;
+
+        public PairInner(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        // 交换方法
+        public PairInner<V, K> swap() {
+            return new PairInner<>(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) {
+        // 测试 Pair
+        PairInner<String, Integer> pair = new PairInner<>("成绩", 95);
+        PairInner<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("姓名"));
+    }
+}