feat: 新增复习/JavaSE阶段复习资料——整理阶段00~阶段07核心知识点总纲文档（阶段00编程基础预热-进制与编码/阶段01Java语言基础/阶段02面向对象编程/阶段03异常处理与集合框架/阶段04Java8新特性-Lambda与Stream/阶段05IO流与文件操作/阶段06多线程与并发编程/阶段07JVM类加载与反射），按章节阶段系统梳理JavaSE全部核心知识点并附必背口诀

复习/JavaSE阶段/阶段00-编程基础预热-进制与编码.md

@@ -0,0 +1,207 @@
+# 阶段0：编程基础预热 —— 进制与编码（预科补遗）
+
+> 对应预科知识点：`知识点/00-Java预科-知识点/`
+> 说明：预科中的**数据类型与运算符**、**流程控制与循环结构**已融入阶段01（Java 语言基础），不再重复。
+> 本阶段专门整理预科中**后续阶段（阶段01~07）未覆盖**的独立知识点：**进制与进制转换、ASCII 字母对照表、预科经典算法**。
+
+---
+
+## 一、进制与进制转换（核心补遗）
+
+> 预科文档：`20260710-进制与进制转换.md`
+> 阶段01~07 均未专门讲解进制，本部分为**必补重点**。
+
+### 1. 为什么计算机使用二进制
+
+- 计算机由晶体管组成，只有**通电（1）**和**断电（0）**两种状态
+- 两种状态最稳定可靠、电路设计最简单
+- **计算机使用二进制不是因为二进制高级，只是因为硬件只识别通电/断电**
+
+### 2. 四种进制与 Java 前缀（必背）
+
+| 进制 | 基数 | 数字符号 | Java 前缀 |
+|------|------|---------|-----------|
+| 二进制 | 2 | 0, 1 | `0b` / `0B` |
+| 八进制 | 8 | 0~7 | `0` |
+| 十进制 | 10 | 0~9 | 正常写 |
+| 十六进制 | 16 | 0~9, A~F | `0x` / `0X` |
+
+**十六进制 A~F 对应值：** A=10, B=11, C=12, D=13, E=14, F=15
+
+### 3. 编码与解码
+
+| 概念 | 方向 | 说明 |
+|------|------|------|
+| **编码（Encode）** | 人 → 机器 | 把人类可读信息（文本/数字/图片）转成二进制数据 |
+| **解码（Decode）** | 机器 → 人 | 编码的逆过程，把二进制转回人类可读信息 |
+
+### 4. 按权展开法（任意进制 → 十进制，必会）
+
+**方法：每一位数字 × 位权，再求和。** 二进制位权从右往左：`2⁰, 2¹, 2², 2³...`
+
+**示例：**
+- 二进制 `0b1101` = 1×8 + 1×4 + 0×2 + 1×1 = **13**
+- 二进制 `0b1001` = 1×8 + 0×4 + 0×2 + 1×1 = **9**
+- 八进制 `0257` = 2×8² + 5×8¹ + 7×8⁰ = **175**
+- 十六进制 `0x3F` = 3×16¹ + 15×16⁰ = **63**
+
+### 5. 除基取余法（十进制 → 任意进制，必会）
+
+**方法：不断除以目标进制，取余数，从下往上排列余数。**
+
+**示例：十进制 25 → 二进制**
+```
+25 ÷ 2 = 12 余 1
+12 ÷ 2 = 6  余 0
+6  ÷ 2 = 3  余 0
+3  ÷ 2 = 1  余 1
+1  ÷ 2 = 0  余 1
+从下往上读：11001
+```
+
+**练习答案（自测）：**
+- 357 → 二进制 `101100101`、八进制 `545`、十六进制 `165`
+- 1234 → 二进制 `10011010010`、八进制 `2322`、十六进制 `4D2`
+
+### 6. 8进制/16进制 与二进制互转（3 位 / 4 位一组）
+
+- **每 3 位二进制 = 1 位八进制**：`001 101 111` → `1 5 7`
+- **每 4 位二进制 = 1 位十六进制**：`1101 1110 1010 0101` → `D E A 5`
+
+**十六进制常见用途：** 颜色色值、内存地址、MAC 地址、文件权限等。
+
+### 7. Java 代码示例
+
+```java
+int a = 0b0101011;     // 二进制，前缀 0b
+int b = 01234567;      // 八进制，前缀 0
+int c = 0x123AFEC9;    // 十六进制，前缀 0x
+System.out.println(a); // Java 自动转换为十进制输出
+```
+
+## 二、ASCII 字母对照表（编码基础补遗）
+
+> 预科文档：`20260710-ASCII字母对照表.md`
+> 阶段01 仅在 char 类型处简单提及 ASCII 码值，本部分为**系统整理**。
+
+### 1. ASCII 编码概念
+
+**ASCII（American Standard Code for Information Interchange）**：美国标准信息交换码，用数字（编码值）表示字符的编码体系。字符在计算机中本质存储为二进制数，ASCII 码表规定了常用字符与整数的对应关系。
+
+### 2. 常用字符的十进制值（必背）
+
+| 字符范围 | 十进制值 | 说明 |
+|---------|----------|------|
+| 空格 | **32** | |
+| 数字 `'0'` ~ `'9'` | **48 ~ 57** | 共 10 个 |
+| 大写 `'A'` ~ `'Z'` | **65 ~ 90** | 共 26 个 |
+| 小写 `'a'` ~ `'z'` | **97 ~ 122** | 共 26 个 |
+| 换行 `\n` (LF) | 10 | |
+| 回车 `\r` (CR) | 13 | |
+| 退格 | 8 | |
+| 制表符 `\t` | 9 | |
+
+### 3. 大小写字母转换技巧（必背）
+
+- `'a'` - `'A'` = **32**（0x20）
+- **小写字母 = 大写字母 + 32**
+- **大写字母 = 小写字母 - 32**
+
+```java
+char c2 = 67;   // 对应 'C'（67 在 65~90 之间）
+char c6 = 97;   // 对应 'a'
+System.out.println(c1 >= 'A' && c1 <= 'Z');  // 判断是否大写字母
+```
+
+### 4. Java 中判断字符类型
+
+```java
+// 判断是否为大写字母：字符比较 >= 'A' && <= 'Z'（或 >=65 && <=90）
+char ch = 'A';
+System.out.println(ch >= 'A' && ch <= 'Z');  // true
+```
+
+### 5. 字符与整数在 Java 中的互转（衔接阶段01）
+
+```java
+char cc = 'A';
+int d1 = cc + 6;         // 'A' 的 ASCII 码 65 + 6 = 71
+System.out.println(d1);  // 71
+char c6 = 97;            // 直接为 char 赋整数值
+System.out.println(c6);  // 'a'（97 对应 'a'）
+```
+
+## 三、预科经典算法（后续阶段未系统覆盖）
+
+> 来源：预科 `20260710-进制与进制转换.md` 末尾，阶段01~07 未专门整理，但属基础必会算法。
+
+### 1. 斐波那契数列（前 10 项）
+
+第 1 项为 0，第 2 项为 1，从第 3 项开始每项 = 前两项之和。
+```java
+int a = 0, b = 1;
+for (int i = 3; i <= 10; i++) {
+    int c = a + b;
+    a = b;
+    b = c;      // 变量前移
+}
+```
+> 核心技巧：`a = b; b = c;` 前移。
+
+### 2. 判断素数
+
+大于 1 的自然数，除了 1 和它本身外没有其他因数。
+```java
+int n = 17;
+boolean b = n > 1;
+for (int i = 2; i <= n; i++) {
+    if (n % i == 0) { b = false; break; }
+}
+```
+> 核心技巧：`for` + `if` + `break`。
+
+### 3. 正负交替求和（1 - 1/2 + 1/3 - ...）
+
+```java
+double sum = 0;
+for (int i = 1; i <= 10; i++) {
+    if (i % 2 == 1) sum += 1.0 / i;   // 奇数项为正
+    else            sum -= 1.0 / i;   // 偶数项为负
+}
+System.out.printf("%.2f", sum);
+```
+> ⚠️ 浮点除法必须用 `1.0 / i`，否则整数除法截断为 0。
+
+### 4. 判断回文数（正反读一样，如 12321）
+
+```java
+int n = 12321, a = n, b = 0;
+while (n > 0) {
+    b = b * 10 + n % 10;   // 拼接反转
+    n /= 10;
+}
+System.out.println(a == b ? "yes" : "no");
+```
+> 核心技巧：`% 10` 取最后一位，`b = b*10 + 位` 拼接反转。
+
+### 5. 阶乘求和（1! + 2! + ... + 10!）
+
+```java
+int sum = 0, f = 1;
+for (int i = 1; i <= 10; i++) {
+    f *= i;      // 计算当前阶乘
+    sum += f;    // 累加
+}
+```
+> 核心技巧：`f *= i` 同时累积阶乘与总和。
+
+## 本阶段必须背诵的核心口诀
+
+1. **计算机用二进制，只是因为硬件只认通电/断电**
+2. **进制前缀**：二进制 `0b`、八进制 `0`、十六进制 `0x`
+3. **进制转换两把刀**：按权展开（任意→十进制）、除基取余（十进制→任意）
+4. **二进制看 8/16 进制**：3 位一组看 8、4 位一组看 16
+5. **ASCII 必背**：空格 32、数字 48、大写 65、小写 97
+6. **大小写转换**：小写 = 大写 + 32（即 `'a' - 'A' = 32`）
+7. **char 本质是数值**：`'A' + 6 = 71`、`char c = 97;` → 'a'
+8. **经典算法**：斐波那契（变量前移）、素数（取余+break）、回文（反转拼接）、阶乘（`f*=i` 累积）

复习/JavaSE阶段/阶段01-Java语言基础.md

@@ -0,0 +1,180 @@
+# 阶段一：Java 语言基础 —— 核心知识点总纲
+
+> 本阶段涵盖：**Java 入门与数据类型、流程控制与运算符、分支循环与数组、数组进阶与排序算法、方法与 Random**
+> 细分文档：`按日细分/20260713-笔记.md` ~ `按日细分/20260717-笔记.md`
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、Java 入门与数据类型（对应 07-13）
+
+### 1. Java 文件结构与注释
+- `.java` 源文件 = Java 代码 + 注释（注释不参与编译运行）
+- 三种注释：单行 `//`、多行 `/* */`、文档 `/** */`（生成 API 文档）
+
+### 2. 基本数据类型（4 类 8 种，必背）
+| 类型 | 位数 | 字节 | 范围 |
+|------|------|------|------|
+| byte | 8 | 1 | -2⁷ ~ 2⁷-1 |
+| short | 16 | 2 | -2¹⁵ ~ 2¹⁵-1 |
+| int | 32 | 4 | -2³¹ ~ 2³¹-1 |
+| long | 64 | 8 | -2⁶³ ~ 2⁶³-1 |
+| float | 32 | 4 | ±3.4×10³⁸ |
+| double | 64 | 8 | ±1.8×10³⁰⁸ |
+| char | 16 | 2 | 0~65535（Unicode） |
+| boolean | 1 | 1 | true/false |
+
+- 整数默认 `int`、小数默认 `double`；`long` 加 `L`、`float` 加 `F`
+- 存储单位：1B = 8bit；1KB=1024B；1MB=1024KB；1GB=1024MB；1TB=1024GB
+
+### 3. 基本类型 vs 引用类型（四大区别必背）
+| 维度 | 基本类型 | 引用类型 |
+|------|---------|---------|
+| 存什么 | 直接存"值" | 存空间地址值 |
+| 默认值 | 0 / 0.0 / false | null |
+| 赋值 | 复制值，独立 | 复制地址，可能共享 |
+| 比较 | 比较值 | 比较地址 |
+
+> ⚠️ **String 不是关键字**，是引用类型（类），大驼峰命名。
+
+### 4. 类型转换（必背方向）
+- **自动转换**：`byte → short → int → long → float → double`
+- **强制转换**：`(目标类型) 变量`；可能丢精度（`(int)3.94 = 3`）、可能溢出（`(byte)128 = -128`）
+- **表达式提升**：byte/short/char 参与运算自动提升为 int
+- **整数除法截断**：`10/3 = 3`（不四舍五入）
+- **char 本质是数值**：`'A' + 6 = 71`；`char c6 = 97;` → 'a'
+
+### 5. 编码表与 var
+- ASCII（1字节）/ GBK（中文）/ Unicode（2字节）/ UTF-8（变长，互联网常用）
+- **var（JDK10+）**：编译时语法糖，只在局部变量用，Java 仍是强类型语言
+
+## 二、流程控制与运算符（对应 07-14）
+
+### 1. 程序三大结构
+顺序结构、分支结构（if-else）、循环结构
+
+### 2. 算术/赋值/比较运算符要点
+- 整数除法截断；0 不能做除数（整数抛 ArithmeticException，浮点得 Infinity/NaN）
+- 取模符号与被除数一致：`-10 % 3 = -1`
+- **复合赋值隐含强转**：`a += 6` 可，`a = a + 6` 报错
+- **浮点精度陷阱**：`0.1 + 0.2 == 0.3` 为 false，用 printf 或误差范围比较
+
+### 3. 逻辑运算符（必背真值表）
+| 运算符 | 名称 | 短路特性 |
+|--------|------|---------|
+| `&` | 与 | 无 |
+| `\|` | 或 | 无 |
+| `!` | 非 | 单目 |
+| `&&` | 短路与 | **左边 false 右边不执行** |
+| `\|\|` | 短路或 | **左边 true 右边不执行** |
+| `^` | 异或 | 相同 false、不同 true |
+
+### 4. 位运算符（操作整型二进制位）
+| 运算符 | 规律 |
+|--------|------|
+| `&` / `\|` / `^` / `~` | 按位与/或/异或/取反 |
+| `<<` | 左移，**×2ⁿ**（低位补0） |
+| `>>` | 右移，**÷2ⁿ**（高位补符号位） |
+| `>>>` | 无符号右移，高位补0，负数变大正数 |
+
+### 5. 三目运算符与优先级
+- `布尔 ? 表达式1 : 表达式2`；简单二选一赋值用三目，复杂用 if-else
+- **优先级口诀**：括号最高 → 单目 → 乘除 → 加减 → 移位 → 比较 → 相等 → 位逻辑 → 短路逻辑 → 三目 → 赋值最低
+
+## 三、分支循环与数组（对应 07-15）
+
+### 1. switch 分支
+- `if` 范围匹配，`switch` **具体值匹配**
+- 传统：`case 值:` + `break;`（不写 break 会穿透）
+- 增强 switch（JDK17+）：`case 值 ->` 自带 break、多值匹配 `case "1","2" ->`、switch 表达式必须有 default
+
+### 2. 三种循环对比（必背）
+| 循环 | 判断时机 | 最少执行次数 |
+|------|---------|------------|
+| for | 先判断后执行 | 0 |
+| while | 先判断后执行 | 0 |
+| do...while | 先执行后判断 | **1** |
+
+### 3. 循环控制（必背）
+- `break`：结束整个循环（循环外继续）
+- `continue`：结束本轮循环（进入下一轮）
+- `return`：结束整个方法（循环外也不执行）
+
+### 4. 数组（引用类型）
+- 特点：连续存储、索引访问、固定长度、同类型、索引从 0 开始
+- **动态初始化** `new int[10]`（程序员定长度，默认值）；**静态初始化** `{1,3,5}`（程序员赋值）
+- 默认值：int→0、double→0.0、boolean→false、引用→null
+- 遍历：`for (int i = 0; i < arr.length; i++)`
+- ⚠️ 越界抛 `ArrayIndexOutOfBoundsException`
+
+### 5. 经典算法
+闰年、三数最大值（嵌套三目）、水仙花数（取位：`/100`、`/10%10`、`%10`）、数字加密（取位→加5→%10→互换）、变量交换（加减法/异或法）
+
+## 四、数组进阶与排序算法（对应 07-16）
+
+### 1. 多维数组与 foreach
+- 二维数组 = 数组的数组（存一维数组引用）；遍历两层循环（外层 `arr.length`、内层 `arr[i].length`）
+- **foreach**：`for (类型 变量 : 数组)`，只能遍历全部，**无法获取索引**
+
+### 2. Arrays 工具类（必背）
+`sort()`、`toString()`、`copyOf()`、`copyOfRange(arr, from, to)`、`binarySearch()`（**必须先排序**）
+
+### 3. 三种排序算法（必会手写，必背对比）
+| 特性 | 冒泡 | 选择 | 插入 |
+|------|------|------|------|
+| 思想 | 相邻比较大的后冒 | 每轮选最小交换 | 插入已排序区正确位置 |
+| 每轮交换 | 多次 | **最多1次** | 多次（后移） |
+| 最好复杂度 | O(n)优化版 | O(n²) | **O(n)** |
+| 稳定性 | ✅ | ❌ | ✅ |
+| 实用性 | 低 | 中 | **高** |
+
+- 冒泡：外层 n-1 轮，内层 `arr.length-1-i`；布尔标记优化提前结束
+- 选择：`minIndex` 记录最小索引，`minIndex != i` 才交换
+- 插入：`current = arr[i]`，从后往前找位置，大元素后移，`arr[j+1] = current`
+
+### 4. Scanner 键盘输入（必会）
+- 四步骤：导包 → `new Scanner(System.in)` → 调用方法 → `close()`
+- `nextInt()`/`nextDouble()`/`next()`/`nextLine()`/`nextBoolean()`/`next().charAt(0)`
+- **陷阱**：`nextInt()` 后 `nextLine()` 读到空串（换行符残留）→ 先调一次 `nextLine()` 吃掉换行
+- `next()` 以空格/换行结束，`nextLine()` 仅以换行结束
+
+## 五、方法与 Random（对应 07-17）
+
+### 1. 方法四种声明方式（必背）
+| 类型 | 格式 | 场景 |
+|------|------|------|
+| 无参无返回值 | `void 方法名()` | 输出固定内容 |
+| 有参无返回值 | `void 方法名(参数)` | 执行操作并输出 |
+| 有参有返回值 | `类型 方法名(参数)` | 计算并返回 |
+| 无参有返回值 | `类型 方法名()` | 获取常量/随机数 |
+
+- 无返回值必须 `void` 占位；有返回值用 `return`
+- **方法中可调用方法**（复用）：`rotundityArea()` 内部调用 `getPI()`
+
+### 2. 数组作为方法参数
+```java
+public static void bubbleSort(int[] arr) { }
+bubbleSort(myScore);   // 直接传数组名
+```
+
+### 3. Random 随机数
+```java
+Random ran = new Random();
+ran.nextInt();         // 任何 int
+ran.nextInt(100);      // 0~99
+ran.nextInt(6) + 1;    // 1~6（偏移）
+```
+> 对比 `Math.random()`：double (0.0~1.0)，需手动运算范围。
+
+## 本阶段必须背诵的核心口诀
+
+1. **整数默认 int，小数默认 double**
+2. **自动转换方向**：byte → short → int → long → float → double
+3. **整数除法砍小数、取模符号随被除数**
+4. **短路与短路或**：&& 左 false 右不跑、|| 左 true 右不跑
+5. **左移×2、右移÷2、无符号右移补0**
+6. **do...while 至少执行一次**
+7. **break 结束整个循环、continue 结束本轮、return 结束方法**
+8. **冒泡稳定、选择不稳定、插入最实用**
+9. **Scanner 陷阱**：nextInt 后 nextLine 需先吃换行
+10. **方法的四象限**：有参/无参 × 有返回值/无返回值

复习/JavaSE阶段/阶段02-面向对象编程.md

@@ -0,0 +1,188 @@
+# 阶段二：面向对象编程（OOP）—— 核心知识点总纲
+
+> 本阶段涵盖：**面向对象基础、构造方法与单例、继承与方法重写、抽象类/final/接口、多态与内部类、匿名内部类与常用 API**
+> 细分文档：`按日细分/20260720-笔记.md` ~ `按日细分/20260727-笔记.md`
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、面向对象基础（对应 07-20）
+
+### 1. 类与对象
+- **类** = 模板/图纸（抽象）；**对象** = 实体（具体）；**1 个类 → 多个对象**
+- 类包含：成员变量（属性）+ 成员方法（行为，无 static）
+- 创建对象：`类名 对象名 = new 类名();`；调用成员：`对象名.成员`
+
+### 2. 成员变量 vs 局部变量（四大区别必背）
+| 维度 | 成员变量 | 局部变量 |
+|------|---------|---------|
+| 位置 | 类内方法外 | 方法内（含参数） |
+| 内存 | **堆** | **栈** |
+| 生命周期 | 随对象 | 随方法 |
+| 默认值 | 有默认值 | **必须先赋值** |
+
+### 3. 对象引用共享
+多个引用指向同一对象时，修改互相影响（`Teacher t2 = t1;` 后 t2 改 t1 也变）。
+
+### 4. 封装（必背）
+- 三大特性：**封装、继承、多态**
+- **封装两步走**：`private` 属性 + public 的 setter（含校验）/ getter
+- 访问修饰符：`public`（所有）、`private`（本类）、`default`（同包）、`protected`（同包+子类）
+- **this 关键字** = 当前对象引用；参数与成员同名时用 `this.成员` 区分（setter 中不能省略）
+
+### 5. 包（Package）
+- 相当于文件夹；**域名倒写命名**（`com.lovecoding.day01`）
+- 声明在源文件第一行；包名与目录一致；**同包免 import**
+
+## 二、构造方法与单例模式（对应 07-21）
+
+### 构造方法 10 大要点（必背）
+1. 方法名 = 类名（大小写相同）
+2. **无返回值类型**（连 void 都不写）
+3. 不能 return 返回值
+4. **创建对象时自动调用**（不能手动调用）
+5. 每个类默认有**隐藏无参构造**
+6. **显式定义后默认构造被覆盖**
+7. **可重载**（参数列表不同即可）
+8. 默认构造权限与类一致
+9. **private 构造可阻止外部创建对象**（单例模式铺垫）
+10. `this(参数)` 调用本类构造（必须第一行）
+
+### 经典算法
+- **Fisher-Yates 洗牌**：从后往前遍历 + 随机交换
+- **回文数**：逐位取余反序与原数比较
+- **setter 校验**：业务规则在 setter 中校验
+
+## 三、继承与方法重写（对应 07-22）
+
+### 1. 继承概念
+- `class 子类 extends 父类`；关键字 extends = 扩展
+- 好处：复用、可维护、建立关系；弊端：**耦合性增强**
+- 使用前提：**is...a 关系**（学生是人的一种 ✓）
+
+### 2. 方法重写 Override（必背）
+- 子类与父类**方法签名完全一致**（方法名+参数列表+返回值类型）
+- `@Override` 注解可选但推荐
+- **重写（父子类）vs 重载（同类）**：重载方法名相同参数不同
+
+### 3. super 关键字（必背）
+`super.方法()` 调父类被重写方法；`super.属性` 访问父类同名属性；`super()` 调父类构造
+
+### 4. Java 继承限制（必背）
+- **单继承**（一个子类只能一个直接父类）
+- **多层继承**（Son → Dad → Granddad）
+- **Object 是所有类的根父类**
+
+### 5. 访问修饰符在继承中
+`private` 不可继承；`protected` 子类可访问（异包子类 ✅）
+
+### 6. 变量就近原则（必背）
+**局部 → 本类成员 → 父类成员 → 祖父类成员 → …… → Object**，都没找到编译报错
+
+### 7. this vs super（必背）
+- this = 本类引用；super = 父类引用
+- 变量/方法/构造三场景对应：`this.成员` vs `super.成员`、`this()` vs `super()`
+- ⚠️ `this()` 和 `super()` **必须第一行、不能同时出现**
+
+### 8. 继承中构造方法（必背）
+- 子类构造**默认第一句 super()**（先完成父类对象创建）
+- **父类没有无参构造** → 子类必须手动 `super(参数)`
+- `super(参数)` 必须在第一行
+
+## 四、抽象类、final 与接口（对应 07-23）
+
+### 1. 抽象类（必背）
+- 无方法体的方法 → 抽象方法；含抽象方法的类 → 抽象类（`abstract` 关键字）
+- **抽象类不能实例化**；可以有构造方法（供 super 调用）
+- 子类：①重写所有抽象方法 ②子类也是抽象类
+- 抽象类不一定有抽象方法，但抽象方法必须在抽象类中
+
+### 2. final 关键字（必背）
+| 修饰 | 作用 |
+|------|------|
+| final 类 | **不能被继承**（String、Math、Integer） |
+| final 方法 | **不能被重写** |
+| final 变量 | **变成常量**（全大写+下划线命名） |
+
+- final 修饰引用：**引用地址不可变，对象内容可改**
+- ⚠️ final 和 abstract 不能同时使用（语义冲突）
+
+### 3. 模板方法设计模式
+父类定义骨架（**模板方法 final 修饰**）+ 子类实现步骤（抽象方法）
+
+### 4. 代码块执行顺序（必背）
+**静态代码块（类加载一次）→ 构造代码块（每次 new、构造前）→ 构造方法**
+
+### 5. 接口（必背）
+- 解决**单继承局限**：单继承 + 多实现
+- 接口成员：变量默认 `public static final`；方法默认 `public abstract`
+- 接口**不能实例化、没有构造方法**
+- 实现：`implements`；可继承父类 + 实现多接口
+- **抽象类 vs 接口**：抽象类可有构造/任意成员/单继承；接口无构造/只常量抽象方法/多实现
+
+### 6. 接口 JDK 版本演进（必背）
+| 版本 | 新增 | 说明 |
+|------|------|------|
+| JDK8 | **默认方法 default** | 有方法体，实现类不强制重写，重写时去掉 default |
+| JDK8 | **静态方法 static** | 接口名直接调用 |
+| JDK9 | **私有方法 private** | 抽取默认/静态方法公共代码 |
+
+## 五、多态与内部类（对应 07-24）
+
+### 1. 多态（必背）
+- **同一个对象在不同时刻表现不同形态**
+- 前提三条件：①继承或实现 ②方法重写 ③**父类引用指向子类对象**
+- 成员访问：**编译看左边，运行看右边**（方法）；成员变量看父类
+- 好处：提高扩展性（开闭原则）；USB 接口案例
+
+### 2. 多态中的转型（必背）
+- **向上转型**：`Person p = new Student();`（自动）
+- **向下转型**：`(Student) p`（前提先向上转型）；用于调用子类特有方法
+- **instanceof**：`对象 instanceof 类型` 返回 boolean，向下转型前安全判断
+
+### 3. 内部类（了解）
+- 类中定义类（心脏之于人）；内部类可访问外部类所有成员（含 private）
+- 成员内部类：`外部类.内部类 对象 = new 外部类().new 内部类();`
+- **设计原则**：内部类私有化 + 外部类公共方法暴露
+- 静态内部类、局部内部类（了解）
+
+## 六、匿名内部类与常用 API（对应 07-27）
+
+### 1. 匿名内部类（必背）
+- **本质**：继承了某个类或实现了某个接口的**子类的匿名对象**
+- 语法：`new 类/接口() { 重写方法 }`
+- 三种使用：①多态接收 ②**作方法参数传递（最常用）** ③直接调用（只能一次）
+- 应用：实现类仅用一次时避免建独立文件、临时逻辑
+
+### 2. String 字符串（必背）
+**内存模型：**
+| 创建方式 | 位置 | 特点 |
+|----------|------|------|
+| 直接赋值 | 字符串常量池 | 序列相同则同一对象 |
+| `new String()` | 堆内存 | 每次 new 新对象 |
+
+- **`==` 比较地址、`equals()` 比较内容**（String 已重写）
+- 常用方法：`equals/equalsIgnoreCase`、`length/charAt`、`substring/indexOf/contains/startsWith/endsWith`、`toUpperCase/toLowerCase/trim/split/replace`
+- **String 不可变**（final 类）；频繁拼接用 `StringBuilder`（单线程，性能高）/ `StringBuffer`（线程安全）
+
+### 3. Math 类（全静态，类名调用）
+`abs/max/min/pow/sqrt/ceil/floor/round/random/PI`
+
+### 4. 日期时间（JDK8 后推荐）
+- `LocalDate`/`LocalTime`/`LocalDateTime` + `DateTimeFormatter`
+- `LocalDate.of(y,m,d)`、`plusDays(5)` 返回新对象、`format(formatter)`
+
+## 本阶段必须背诵的核心口诀
+
+1. **类是模板、对象是实体；一个类可造多个对象**
+2. **成员变量在堆、局部变量在栈、局部必须先赋值**
+3. **封装两步走**：private 属性 + public setter/getter
+4. **this = 当前对象，super = 父类对象；this()/super() 第一行且不同时出现**
+5. **重写（父子类签名一致）vs 重载（同类方法名同参数不同）**
+6. **单继承、多层继承、一切类根 Object**
+7. **变量就近原则**：局部 → 本类 → 父类 → …… → Object
+8. **子类构造默认 super()；父类无无参构造必须手动 super(参数)**
+9. **抽象类不能 new；接口只有常量和抽象方法；单继承 + 多实现**
+10. **多态口诀**：编译看左边、运行看右边
+11. **匿名内部类 = 继承/实现某类接口的匿名子类对象**
+12. **String 用 equals 比较内容；String 不可变、拼接用 StringBuilder**

复习/JavaSE阶段/阶段03-异常处理与集合框架.md

@@ -0,0 +1,166 @@
+# 阶段三：异常处理与集合框架 —— 核心知识点总纲
+
+> 本阶段涵盖：**异常处理与 Object 类、包装类/集合框架/泛型、LinkedList 与手写链表、迭代器/Map 集合/二叉树**
+> 细分文档：`按日细分/20260728-笔记.md` ~ `按日细分/20260731-笔记.md`
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、异常处理与 Object 类（对应 07-28）
+
+### 1. 异常体系（必背）
+```
+Throwable
+    ├── Exception（程序可处理）
+    │     ├── RuntimeException（运行时异常：Arithmetic/ArrayIndexOutOfBounds/NullPointer...）
+    │     └── 非 RuntimeException（编译期异常，必须处理：IOException、SQLException）
+    └── Error（严重问题，无法处理：StackOverflowError、OutOfMemoryError）
+```
+
+### 2. 编译期异常 vs 运行时异常
+- **编译期异常**：编译报错，必须捕获/抛出
+- **运行时异常**：编译不报错，运行后才报错
+
+### 3. 异常处理方式
+- **try-catch**：多 catch 块**子类在前父类在后**
+- **throws**：方法声明后抛出，谁调用谁处理
+- **finally**：**无论是否异常都执行**（常用于资源关闭）；catch 有 return 时 finally 先执行
+- 组合：`try-catch-finally`（完整）/ `try-catch` / `try-finally`（不处理但关资源）
+
+### 4. 异常常用方法
+`getMessage()`（最常用）/ `printStackTrace()` / `getCause()` / `fillInStackTrace()`
+
+### 5. 自定义异常（必背步骤）
+1. 定义异常类
+2. 继承 `Exception`（编译期）或 `RuntimeException`（运行时）
+3. 无参构造 + 有参构造（String message）
+
+### 6. throw vs throws（必背）
+| 维度 | throw | throws |
+|------|-------|--------|
+| 位置 | 方法体内 | 方法声明后 |
+| 后跟 | 异常**对象** | 异常**类名** |
+| 作用 | 实际抛出 | 声明有风险 |
+| 数量 | 一次一个 | 一次多个 |
+
+> 一句话：`throw` 是"干活的"，`throws` 是"贴告示的"。
+
+### 7. Object 类（所有类的根父类）
+- 三个方法：`equals()`、`hashCode()`、`toString()`
+- **equals 默认 == 比较地址**；重写比较业务规则（null → 类型 → 字段）
+- **equals 相等则 hashCode 必须相等**；重写 equals 必须重写 hashCode
+- toString 默认 `包名.类名@哈希码`，重写便于输出对象
+- **Objects 工具类**：`Objects.equals()` / `Objects.hash()` / `Objects.requireNonNull()`
+
+## 二、包装类、集合框架与泛型（对应 07-29）
+
+### 1. 包装类（必背）
+**基本类型 ↔ 包装类：** int→Integer、char→Character、其余首字母大写（Byte/Short/Long/Float/Double/Boolean）
+
+- **装箱**：基本 → 引用（自动装箱底层调 `valueOf()`）
+- **拆箱**：引用 → 基本（自动拆箱底层调 `intValue()`）
+- **缓存机制**：Integer 缓存 -128~127，范围内 `==` 为 true；超出新建
+- ⚠️ **包装类比较用 equals，不用 ==**
+- 常用方法：`Integer.parseInt(String)`、`valueOf()`、`intValue()`、`MAX_VALUE`
+
+### 2. 集合 vs 数组（必背）
+| 维度 | 数组 | 集合 |
+|------|------|------|
+| 长度 | 不可变 | 可变 |
+| 存储 | 基本+引用 | **只能引用**（基本用包装类） |
+| 类型 | 同一种 | 可多种（建议泛型） |
+
+### 3. 集合体系（必背）
+```
+Collection（单列）            Map（双列）
+  ├── List（有序可重复）       ├── HashMap
+  │     ├── ArrayList（数组）  └── TreeMap
+  │     └── LinkedList（链表）
+  └── Set（无序不可重复）
+        ├── HashSet（哈希表）
+        ├── TreeSet（红黑树可排序）
+        └── LinkedHashSet（保持插入顺序）
+```
+
+### 4. 四种线性表结构（必背）
+| 结构 | 特点 | 实现 |
+|------|------|------|
+| 栈 | **先进后出 LIFO** | LinkedList |
+| 队列 | **先进先出 FIFO** | LinkedList |
+| 数组 | 连续，**查询快增删慢** | ArrayList |
+| 链表 | 非连续，**增删快查询慢** | LinkedList |
+
+### 5. ArrayList 底层（重点必背）
+- 本质可变数组（`Object[] elementData`）
+- 默认容量 **10**（懒加载，首次 add 才扩容）
+- **1.5 倍扩容**：`oldCapacity + (oldCapacity >> 1)`
+- `size` = 有效元素个数（非数组长度）；`size <= capacity`
+- 构造：无参（容量0，首次加扩容10）/ 指定容量 / 传入集合
+- 常用方法：`add/get/set/remove/size/isEmpty/contains/indexOf/toArray/getFirst/getLast`
+
+### 6. 泛型（必背）
+- **泛型（JDK1.5）**：编译时类型安全检测 + 避免强转
+- 格式：`<E>`、`<K,V>`、`<T extends 父类>`（有界类型）
+- **通配符**：`?` 无界、`? extends T` 上界、`? super T` 下界
+- **始终优先使用泛型**，避免原始类型
+
+## 三、LinkedList 与手写链表（对应 07-30）
+
+### 1. List.of()（Java 9）
+- **不可变集合**：不能 add/set/remove，抛 UnsupportedOperationException
+- 不接受 null；元素对象本身可改（浅不可变）
+
+### 2. LinkedList 双链表
+- 基于**双链表**实现，同时实现 `List` + `Deque`
+- 节点：`item` + `next` + `prev`
+- **插入删除 O(1)、随机访问 O(n)**
+- 头节点 prev=null；尾节点 next=null
+
+### 3. ArrayList 方法时间复杂度（必背）
+`get/set` O(1)；`add(尾部)` 均摊 O(1)；`add(index)/remove/contains/indexOf` **O(n)**
+
+## 四、迭代器、Map 集合与二叉树（对应 07-31）
+
+### 1. LinkedList 多接口形态
+一个对象多种身份：`List`（列表）/ `Queue`（队列 offer/poll/peek）/ `Deque`（双端 addFirst/pollFirst/push/pop）
+> 接口作为引用类型 = 能力限定（编译看左边）
+
+### 2. Iterator 迭代器（必背）
+- 所有单列集合都有 `iterator()`；**统一遍历方式**，适合无索引集合
+- 方法：`hasNext()`（有无下一个）/ `next()`（取下一个并后移）
+- 模板：`while (it.hasNext()) { it.next(); }`
+- ⚠️ 指针单向移动；迭代中集合被修改抛 `ConcurrentModificationException`
+- foreach 底层就是迭代器
+
+### 3. Map 集合（必背）
+- `Map<K,V>` 双列集合；**Key 唯一、Value 可重复**；**HashMap 无序**
+- 常用方法：`put`（键存在=覆盖修改）/ `get` / `containsKey` / `remove` / `keySet` / `values` / `entrySet`
+- **两种遍历**：
+  - keySet + get：间接遍历（先拿键再反查值）
+  - **entrySet**：直接遍历（getKey/getValue，效率更高）
+
+### 4. HashMap 底层（必背）
+- 结构 = **数组 + 链表**（JDK1.8 后：数组 + 链表/红黑树）
+- 依赖 **hashCode + equals** 保证键唯一；自定义类型作 Key 必须重写两者
+- 默认长度 **16**、负载因子 **0.75**
+- **树化条件**：数组 > 64 **且** 链表 > 8；**退化条件**：链表 < 6
+- JDK1.7 数组+链表；JDK1.8 链表超 8 转红黑树（防链表过长）
+
+### 5. 二叉树理论（了解）
+- 演进：二叉树 → 二叉搜索树（左小右大）→ AVL（左右高差 ≤1，左旋/右旋，LL/LR/RR/RL）→ **红黑树**
+- **红黑树 6 条规则**：①红或黑 ②根黑 ③Nil 叶黑 ④红节点的子节点必须黑（不能双红）⑤任意节点到叶子简单路径黑节点数相同 ⑥插入默认红色
+- TreeMap 完全用红黑树实现
+
+## 本阶段必须背诵的核心口诀
+
+1. **Exception 可捕获处理、Error 不可处理**
+2. **多 catch 子类在前、父类在后**
+3. **finally 无论是否异常都执行（用于关资源）**
+4. **throw 抛对象、throws 声明类**
+5. **equals 相等 hashCode 必相等**
+6. **包装类比较用 equals（注意 -128~127 缓存）**
+7. **集合只能存引用类型、长度可变**
+8. **ArrayList 默认 10、1.5 倍扩容、size 是元素个数**
+9. **List 有序可重复、Set 无序不可重复、Map 键唯一**
+10. **HashMap 数组+链表（1.8 后+红黑树），树化需数组>64 且链表>8**
+11. **Map 遍历：keySet 间接、entrySet 直接更高效**

复习/JavaSE阶段/阶段04-Java8新特性-Lambda与Stream.md

@@ -0,0 +1,159 @@
+# 阶段四：Java 8 新特性 —— Lambda 与 Stream 流 —— 核心知识点总纲
+
+> 本阶段涵盖：**比较器排序与 Lambda、函数式编程与 Stream 流**
+> 细分文档：`按日细分/20260803-笔记.md`、`按日细分/20260804-笔记.md`
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、比较器排序（对应 08-03）
+
+### 1. 有序集合的两种排序方式（必背）
+| 排序方式 | 实现 | 场景 |
+|----------|------|------|
+| **自然排序 Comparable** | 实体类实现 `Comparable`，重写 `compareTo(T o)` | 类设计期确定默认规则 |
+| **比较器排序 Comparator** | 创建集合时传入 `Comparator`，重写 `compare()` | 类已定稿、临时自定义排序 |
+
+- TreeSet / TreeMap 是有序集合（取出时排序过）
+- 能存入条件：实现 Comparable **或** 构造传入 Comparator
+
+### 2. 返回值规则（必背，两种排序共用）
+| 返回值 | 含义 | 处理结果 |
+|--------|------|----------|
+| 负数 | 当前元素小 | 存左边 |
+| **0** | 与已有元素"重复" | **不存**（去重） |
+| 正数 | 当前元素大 | 存右边 |
+
+> **官方推荐**：compareTo == 0 时 equals 返回 true、hashCode 一致——排序/相等/哈希判定一致，去重才符合预期。
+> ⚠️ 只用单个属性排序时，属性相同会"丢"元素 → 叠加**二次比较**（如先年龄后姓名）。
+
+### 3. 降序技巧
+**交换 compare/compareTo 两个参数的位置即可降序**：`Double.compare(o.getSalary(), this.salary)` = 薪资降序。
+
+### 4. Collections 工具类（必背）
+| 方法 | 作用 |
+|------|------|
+| `sort(List)` | 自然升序（元素必须 Comparable） |
+| `sort(List, Comparator)` | 自定义排序 |
+| `reverse(List)` | 逆序 |
+| `binarySearch(List, key)` | 二分查找（**必须先排序**） |
+| `max/min(List)` | 最大/最小 |
+| `unmodifiableList(List)` | 转不可变集合 |
+| `shuffle/fill/swap/rotate/replaceAll` | 打乱/填充/交换/旋转/替换 |
+
+### 5. 可变参数 Varargs（必背）
+- `int... a` **本质就是数组**（`int[] a`），方法内 foreach 遍历
+- **必须放参数列表最后**；一个方法最多一个可变参数
+
+## 二、Lambda 表达式（对应 08-03）
+
+### 1. 概念
+**Lambda（JDK 8）= 简化匿名内部类**的写法。
+**标准格式：** `(形式参数) -> {代码块}`（三要素：参数、箭头、代码块）
+
+### 2. 函数式接口（必背）
+**只有一个抽象方法的接口**叫函数式接口。Lambda 只能用于函数式接口。
+
+**JDK 内置函数式接口（java.util.function 包）：**
+| 接口 | 形态 |
+|------|------|
+| `Supplier<T>` | 无参有返回值 |
+| `Consumer<T>` | 有参无返回值 |
+| `Function<T,R>` | 有参有返回值 |
+| `Predicate<T>` | 有参返回 boolean（断言） |
+
+### 3. Lambda 省略模式（必背三条）
+1. **参数类型可省略**（要么全写、要么全省）
+2. **单参数可省小括号**：`(s) ->` → `s ->`
+3. **单语句可省大括号/分号/return**：`(a, b) -> a + b`
+
+### 4. Lambda vs 匿名内部类
+- 匿名内部类：接口/抽象类/普通类都行、多抽象方法也能用、编译产生 .class
+- **Lambda：只能是接口、必须只有一个抽象方法、编译不产生 .class（运行期动态生成字节码）**
+
+### 5. 典型应用
+```java
+Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
+TreeSet<Employee> set = new TreeSet<>(Comparator.comparing(Employee::getName));
+```
+
+## 三、函数式编程思想（对应 08-04）
+
+**函数式编程**：把计算看作数学中的函数计算，程序由函数组合构成（而非语句序列）。
+五大特点：不可变性、高阶函数、**函数组合**（核心）、无副作用、延迟求值。
+
+> **Stream 流才是真正把函数式编程引入 Java。**
+
+## 四、Stream 流 —— 三类方法（必背）
+
+| 类别 | 作用 | 特点 |
+|------|------|------|
+| **获取方法** | 创建流水线 | 起点（`.stream()`） |
+| **中间方法** | 流水线操作 | 返回新 Stream，**可链式调用** |
+| **终结方法** | 最后一个操作 | **只能有一个**，调用后流结束 |
+
+### 1. 生成 Stream 的四种方式（必背）
+| 数据来源 | 生成方式 |
+|----------|----------|
+| Collection 集合 | `集合.stream()` |
+| Map 集合 | `map.keySet().stream()` / `map.values().stream()` |
+| 数组 | `Arrays.stream(数组)` |
+| 零散数据 | `Stream.of(T... values)`（可变参数） |
+
+> Map 不是 Collection 体系，需先转 Set/Collection 再 stream()。
+
+### 2. 中间操作方法（必背）
+| 方法 | 作用 |
+|------|------|
+| `filter(Predicate)` | 过滤 |
+| `limit(n)` | 截取前 n 个 |
+| `skip(n)` | 跳过前 n 个 |
+| `map(Function)` | 映射（元素转另一种类型） |
+| `concat(a, b)` | 合并两个流（**静态方法**） |
+| `distinct()` | 去重（依赖 equals） |
+
+> `limit + skip` 组合实现**分页**：`skip((pageNo-1)*pageSize).limit(pageSize)`。
+
+### 3. 方法引用（四种形式必背）
+| 形式 | 写法 | 示例 |
+|------|------|------|
+| 类的静态方法 | `类名::静态方法名` | `String::valueOf` |
+| 对象的实例方法 | `对象名::方法名` | `sb::append` |
+| 类的实例方法 | `类名::方法名` | `String::substring` |
+| 类的构造方法 | `类名::new` | `String::new` |
+
+> 使用前提：方法体只有一行代码，且抽象方法的**所有参数按顺序**传入被引用方法。
+> `类名::方法名` 形式下，抽象方法**第一个参数**就是调用成员方法的对象。
+
+### 4. 终结操作方法（必背）
+| 方法 | 作用 |
+|------|------|
+| `forEach(Consumer)` | 遍历（参数是有参无返回值） |
+| `count()` | 计数（**返回 long**） |
+
+### 5. 收集操作方法（必背）
+| 方法 | 收集目标 |
+|------|----------|
+| `Collectors.toList()` | List（**不可变**） |
+| `Collectors.toSet()` | Set（天然去重） |
+| `Collectors.toMap(keyMapper, valueMapper)` | Map（键必须唯一，冲突抛 IllegalStateException） |
+| `Stream.toList()` | List（不可变） |
+| `toArray()` | 数组 |
+
+```java
+List<String> nameList = list.stream().map(Student::getName).collect(Collectors.toList());
+Map<Integer, Student> map = list.stream().collect(Collectors.toMap(s -> s.getId(), s -> s));
+```
+
+## 本阶段必须背诵的核心口诀
+
+1. **Comparable 写进类、Comparator 传参临时换**
+2. **compareTo 返回 0 = 重复不存；负数左、正数右**
+3. **降序技巧 = 交换参数位置**
+4. **可变参数本质是数组、必须放最后**
+5. **Lambda 只能简化的函数式接口（只有一个抽象方法）**
+6. **省略三规则**：类型可全省、单参省括号、单语句省大括号/分号/return
+7. **Stream 三类方法**：获取 → 中间（可链式）→ 终结（只能一个）
+8. **filter 过滤、map 映射、limit/skip 分页、distinct 去重**
+9. **方法引用 `::` 四种形式**：静态/对象实例/类实例/构造
+10. **collect 收集**：toList（不可变）、toSet（去重）、toMap（键唯一）

复习/JavaSE阶段/阶段05-IO流与文件操作.md

@@ -0,0 +1,217 @@
+# 阶段五：IO 流与文件操作 —— 核心知识点总纲
+
+> 本阶段涵盖：**File 文件操作与 IO 流入门、IO 缓冲流与字符流、转换流与对象序列化**
+> 细分文档：`按日细分/20260806-笔记.md`、`按日细分/20260807-笔记.md`、`按日细分/20260808-笔记.md`（转换流/序列化部分）
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、File 文件操作类（对应 08-06）
+
+### 概念
+`File` 是**文件和目录路径名的抽象表示**——**不一定是真实存在的文件，只是一个路径名**。File **只描述路径、不做真正的读写**（真正读写用 IO 流）。
+
+### 三种构造方法
+```java
+new File(String pathname)
+new File(String parent, String child)
+new File(File parent, String child)
+```
+
+### 路径概念
+- 分隔符：Windows `\`；Linux/UNIX `/`
+- 绝对路径：从盘符/根目录开始（快递地址）；相对路径：相对某位置（前后左右）
+
+### 常用方法（必背）
+| 分类 | 方法 |
+|------|------|
+| 创建 | `createNewFile()`（抛 IOException）/ `mkdir()` / `mkdirs()`（多级） |
+| 删除 | `delete()` |
+| 判断 | `isFile()` / `isDirectory()` / `exists()` |
+| 获取 | `getAbsolutePath()` / `getPath()` / `getName()` / `listFiles()`（File[] 数组） |
+
+## 二、IO 流基础概念（对应 08-06）
+
+### 分类（两个维度必背）
+| 维度 | 类别 |
+|------|------|
+| 按数据流向 | 输入流（读）、输出流（写） |
+| 按数据类型 | **字节流**（byte）、**字符流**（char） |
+
+### 使用场景推荐（必背）
+- **纯文本（.txt）**：字符流（1 字符 = 2 字节）
+- **其他任何文件**（图片/视频/Word 等）：字节流
+- **不确定类型**：字节流
+
+### 字节流两大抽象父类
+- `OutputStream` / `InputStream`；子类名以父类名作后缀（FileOutputStream、FileInputStream）
+
+## 三、字节流读写（对应 08-06）
+
+### FileOutputStream（输出）
+**使用三步：①创建流对象 ②调用写方法 ③关闭流**
+- 构造：`(File)` / `(String)` / `(File, append)` / `(String, append)`——`append=true` 追加否则覆盖
+- 写方法：`write(int b)` / `write(byte[] b)` / `write(byte[] b, off, len)`
+- 字符串写入前先 `getBytes()`
+- 换行符：Linux `\n`；Windows `\r\n`；macOS `\r`
+
+### FileInputStream（输入）
+**使用三步：①创建流对象 ②调用读方法 ③关闭流**
+- 读方法：`read()` / `read(byte[] b)` / `read(byte[] b, off, len)`
+- **关键返回值**：`read()` 返回 **-1 表示 EOF**；`read(byte[])` 返回**本次有效长度**
+
+**经典循环读写法（必背）：**
+```java
+FileInputStream fis = new FileInputStream("E:/我的文件.txt");
+byte[] bytes = new byte[1024];
+int length;
+while ((length = fis.read(bytes)) != -1) {
+    System.out.println(new String(bytes, 0, length, Charset.forName("UTF-8")));
+}
+fis.close();
+```
+> 用 **try-catch-finally** 关闭资源，finally 保证 close()。
+
+### 文件复制（输入 + 输出配合）
+```java
+byte[] bytes = new byte[4096];       // 缓冲区思想：一次读/写一批
+int length;
+while ((length = fis.read(bytes)) != -1) {
+    fos.write(bytes, 0, length);     // 只写本次有效字节
+}
+fos.close();  // 先关输出流，再关输入流
+fis.close();
+```
+> 缓冲区越大、磁盘 I/O 越少、效率越高。耗时统计用 `System.currentTimeMillis()`。
+
+## 四、缓冲流与字符流（对应 08-07）
+
+### 1. 面向接口编程（CopyFile 接口）
+接口定义复制规范，多种实现（普通字节流 vs 缓冲流），调用方只依赖接口——**多态可随时替换**。
+
+### 2. 字节缓冲流（必背）
+- `BufferedOutputStream` / `BufferedInputStream`：**包装流/装饰流**，给底层字节流加缓冲
+- **减少磁盘 I/O 次数**，显著提升效率；默认缓冲区 8192 字节（8KB）
+- 构造参数是底层流：`new BufferedOutputStream(fos)`
+
+### 3. 基础流 vs 扩展流（必背）
+- **基础流**（FileInputStream/FileOutputStream）**直接操作文件**——数据源头与终点
+- **扩展流**（缓冲流）**不直接操作文件**，用来**操作基础流**——叠加增强能力
+
+**包装流程**：先建文件流 → 缓冲流包装 → 操作缓冲流 → 关闭（先关缓冲再关底层）
+
+### 4. flush() 刷新（必背）
+缓冲流默认**缓冲区满了才落盘**；`flush()` 手动强制刷新。
+> close() 之前会自动 flush 一次；flush 用于"不关闭流但需及时看到数据"。
+
+### 5. 字符流（必背）
+**字符流 = 字节流 + 字符集编码表**——解决字节流操作中文不方便的问题。
+
+**字符集：** ASCII / GB-2312 / GBK / Unicode(UTF-8)
+- **编码**：`字符串.getBytes()`（字符串 → 字节）
+- **解码**：`new String(byte[])`（字节 → 字符串）
+
+**字符流体系：**
+```
+Reader（输入字符流抽象类）→ FileReader
+Writer（输出字符流抽象类）→ FileWriter
+```
+
+**字符流核心优势（必背）：**
+- **可直接 `write(String)` 写字符串，无需 getBytes()**——操作中文方便
+- **自带缓冲区**，写后需 `flush()`
+- `read()` 返回 -1 表示 EOF；`read(char[])` 返回有效字符数
+- 构造可指定字符集（Charset）解决乱码
+
+### 6. 字符缓冲流（必背）
+| 流 | 特有方法 | 说明 |
+|----|----------|------|
+| `BufferedWriter` | `newLine()` | 写**跨平台行分隔符** |
+| `BufferedReader` | `readLine()` | 读一行（不含终止符），**EOF 返回 null** |
+
+**经典逐行读（必背）：**
+```java
+BufferedReader br = new BufferedReader(new FileReader("D:/scores.txt"));
+String line;
+while ((line = br.readLine()) != null) { ... }
+br.close();
+```
+
+### 7. IO 流体系总览（必背）
+```
+基础流：
+    字节流：InputStream → FileInputStream / OutputStream → FileOutputStream
+    字符流：Reader → FileReader / Writer → FileWriter
+处理流（扩展流）- 缓冲流：
+    缓冲字节流：BufferedInputStream / BufferedOutputStream
+    缓冲字符流：BufferedReader / BufferedWriter
+```
+**选型口诀**：不确定用字节流；纯文本用字符流；要效率加缓冲流。
+
+## 五、转换流与对象序列化（对应 08-08）
+
+### 1. 转换流（字符集转码必背）
+**乱码根源**：同一字节在不同字符集含义不同——用 A 编码、用 B 解码就乱码。
+模型：`字符 --编码--> 字节 --解码--> 字符`
+
+| 桥梁 | 父类 | 方向 | 动作 |
+|------|------|------|------|
+| `InputStreamReader` | Reader | **字节 → 字符** | **解码** |
+| `OutputStreamWriter` | Writer | **字符 → 字节** | **编码** |
+
+```java
+new InputStreamReader(new FileInputStream("D:/abc.txt"), "UTF-8");   // 读端指定源编码
+new OutputStreamWriter(new FileOutputStream("D:/hello.txt"), "GBK"); // 写端指定目标编码
+```
+
+### 2. 对象序列化（必背）
+**对象持久化**：把内存对象保存到磁盘 / 网络传输——本质是把对象变成**字节序列**（含类型、数据、属性）。
+
+```
+序列化：对象 --ObjectOutputStream.writeObject()--> 字节序列 --> 文件
+反序列化：文件 --ObjectInputStream.readObject()--> 字节序列 --> 内存重构对象
+```
+- **必须实现 `Serializable` 接口**（标记接口：无方法无属性，仅作"可序列化"标识）
+- `readObject()` 返回 Object，需**强转**；抛 `ClassNotFoundException`
+
+### 3. serialVersionUID（必背）
+- 序列化后修改类结构（增删属性），再反序列化抛 `InvalidClassException`
+- **解决**：显式声明 `private static final long serialVersionUID = 42L;`
+- 作用：①验证版本一致性 ②未声明时 JVM 按类结构自动生成 ③类结构变 → 版本号变 → 报错
+- **最佳实践**：实现 Serializable 的类都显式声明（值无所谓，两端一致即可）
+
+### 4. transient（必背）
+`transient` 修饰的成员**不参与序列化**，反序列化为默认值（引用 null）。
+
+### 5. 序列化 6 条注意事项（必背）
+1. **静态属性不序列化**（属于类，不属于对象）
+2. transient 属性不序列化
+3. **父类实现 Serializable → 子类自动可序列化**
+4. **反序列化不调用构造方法**
+5. **引用链上所有对象必须可序列化**（否则 NotSerializableException）
+6. 单例对象需重写 `readResolve()`
+
+### 6. IO 流体系总结（必背）
+```
+基础流：字节流（FileInputStream/FileOutputStream）、字符流（FileReader/FileWriter）
+处理流：缓冲流（BufferedInputStream/OutputStream、BufferedReader/Writer）
+        转换流（InputStreamReader 解码 / OutputStreamWriter 编码）
+        对象流（ObjectOutputStream 序列化 / ObjectInputStream 反序列化）
+```
+- 四个通用方法：write / read / flush / close
+- 特殊方法：readLine/newLine（缓冲字符流）、writeObject/readObject（对象流）
+- 特殊属性：serialVersionUID；特殊关键字：transient
+
+## 本阶段必须背诵的核心口诀
+
+1. **File 只管路径，不真正读写；读写用 IO 流**
+2. **IO 流三步走：创建 → 读写 → 关闭**
+3. **纯文本字符流、其他字节流、不确定用字节流**
+4. **read() 返回 -1 = EOF；read(byte[]) 返回有效长度**
+5. **文件复制 = 输入流读 + 输出流写 + 缓冲区循环**
+6. **缓冲流 = 包装流，减少磁盘 I/O；基础流直接操作文件**
+7. **字符流可直接 write(String)，自带缓冲区要 flush**
+8. **readLine() 一次读一行、EOF 返回 null；newLine() 跨平台换行**
+9. **转换流：Input 解码（字节→字符）、Output 编码（字符→字节）**
+10. **序列化必须实现 Serializable；serialVersionUID 防类结构变化报错；transient 跳过序列化**
+11. **流用完必须 close()（先关外层再关底层），finally 或 try-with-resources 保证**

复习/JavaSE阶段/阶段06-多线程与并发编程.md

@@ -0,0 +1,263 @@
+# 阶段六：多线程与并发编程 —— 核心知识点总纲
+
+> 本阶段涵盖：**多线程入门、线程操作与线程安全、volatile/Lock 锁/线程池**
+> 细分文档：`按日细分/20260808-笔记.md`（多线程入门部分）、`按日细分/20260810-笔记.md`、`按日细分/20260811-笔记.md`
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、多线程入门（对应 08-08）
+
+### 1. 基本概念（必背）
+| 概念 | 说明 |
+|------|------|
+| **程序** | 硬盘中的文件，静态代码 |
+| **进程** | **内存中正在执行的程序**，占用 CPU/内存等资源 |
+| **线程** | **进程中的单个顺序控制流**，一条执行路径；一个进程可含多线程 |
+
+- **main 方法 = 主线程**
+- 进程三大特性：独立性、动态性、并发性
+
+### 2. 并行 vs 并发（必背）
+| 概念 | 含义 | 类比 |
+|------|------|------|
+| **并行** | 同一时刻多指令在**多个 CPU** 上同时执行 | 3 灶台 3 厨师 |
+| **并发** | 同一时刻多指令在**单个 CPU** 上交替执行 | 3 灶台 1 厨师 |
+
+### 3. 实现多线程的三种方式（必背）
+
+**方式一：继承 Thread**
+步骤：①继承 Thread ②重写 run() ③创建对象 ④start() 启动
+- **run()**：封装被线程执行的代码；**直接调用不创建新线程**
+- **start()**：**启动新线程**，由 JVM 调用 run()
+
+**方式二：实现 Runnable（更推荐）**
+步骤：①implements Runnable ②重写 run() ③创建对象 ④`new Thread(对象, "线程名")` ⑤start()
+```java
+Thread t = new Thread(new RunnableImpl(), "光头强线程！");
+t.start();
+```
+**为什么更推荐：** 不占单继承位、可多实现接口、任务与线程**解耦**（组合优于继承）。
+三种提供方式：实现类对象 / 匿名内部类 / **Lambda**（Runnable 是函数式接口）。
+
+**方式三：实现 Callable + FutureTask（可返回结果）**
+步骤：①implements Callable\<V\> ②重写 call() ③创建对象 ④`new FutureTask<>(callable)` ⑤`new Thread(futureTask)` ⑥start() ⑦`get()` 获取结果
+- `call()` **带返回值**（对比 run() 无返回值）
+- `FutureTask` 是"中间人"；`get()` 阻塞等待计算结果
+
+**三种方式对比：**
+| 维度 | 继承 Thread | 实现 Runnable | 实现 Callable |
+|------|------------|--------------|---------------|
+| 返回结果 | 无 | 无 | **有** |
+| 扩展性 | 差 | 强 | 强 |
+| 直接用 Thread 方法 | 可以（this 是线程） | `Thread.currentThread()` | 同左 |
+| 推荐 | 入门 | 更推荐 | 需返回结果 |
+
+**Thread 常用方法：** `setName/getName`、`Thread.currentThread()`（静态，返回当前线程对象）
+
+## 二、线程操作（对应 08-10）
+
+### 1. sleep 与线程调度
+- **`Thread.sleep(毫秒)`**：静态方法，当前线程休眠（抛 InterruptedException）
+- **线程调度**：分时调度（轮流均分）vs **抢占式调度（Java 采用）**——高优先级机会多
+- **执行随机性**：谁抢到 CPU 时间片不确定 → 多线程输出顺序随机
+
+### 2. 线程优先级
+`getPriority()`（默认 5）/ `setPriority(int)`（范围 1~10）
+
+### 3. 守护线程（必背）
+- **守护线程**随其他非守护线程（用户线程）结束而结束
+- **JVM 退出条件**：所有用户线程都结束才退出；守护线程不阻碍退出；**main 结束 ≠ JVM 退出**
+- `setDaemon(true)` 必须在 `start()` **之前**，否则 IllegalThreadStateException
+- 守护线程创建的子线程默认也是守护线程
+- **finally 不保证**：JVM 强杀时 finally 不一定执行，不能用于资源清理
+- 经典场景：GC 线程、心跳检测、后台日志
+
+### 4. 线程 6 种状态（必背）
+| 状态 | 枚举 | 触发 |
+|------|------|------|
+| 新建 | NEW | new Thread() 未 start() |
+| 可运行 | RUNNABLE | start() 后运行或等时间片 |
+| 阻塞 | BLOCKED | 抢同步锁失败 |
+| 等待 | WAITING | wait() / join() / park() |
+| 计时等待 | TIMED_WAITING | sleep(ms) / wait(timeout) / join(timeout) |
+| 终止 | TERMINATED | run() 结束（终点站） |
+
+- **RUNNABLE 是总枢纽**（阻塞状态都能回到 RUNNABLE）；**TERMINATED 不可逆**
+- OS 5 状态（就绪/运行分开）vs Java 6 状态（就绪+运行合并为 RUNNABLE）
+
+### 5. 线程操作方法（必背）
+| 方法 | 作用 |
+|------|------|
+| `join()` / `join(ms)` | 当前线程等待目标线程结束 / 限时等待 |
+| `interrupt()` | **设置中断标志**（不杀线程）；sleep/wait/join 中抛异常并清标志 |
+| `yield()` | 主动让出 CPU（只是**建议**） |
+| `isAlive()` | 判断线程是否存活 |
+| `wait()` / `notify()` / `notifyAll()` | **Object 类**方法：等待/唤醒（需持有锁） |
+
+**interrupt 机制**：只设标志、请求线程自行响应；`isInterrupted()` 主动检查；catch 后**重设标志**（`Thread.currentThread().interrupt()`）。
+
+## 三、线程安全（对应 08-10）
+
+### 1. 数据竞争
+线程间**共享数据和内存**。多线程同时读写同一共享变量 → 结果不可预测、错误无法复现。
+
+### 2. 两个经典 Bug
+- **卖票问题**：相同票多次出现（同时通过 if 判断）+ 负数票（tickets-- 连续执行）
+- **计数器问题**：`count++` 不是原子操作（**读-改-写 3 步**），理论 1000 实际小于 1000
+
+### 3. 线程安全 3 原因（缺一不可）
+1. **多线程环境**（至少两条路径并发）
+2. **存在共享数据**
+3. **读-改-写复合操作**（count++、tickets--）
+
+### 4. 线程安全三大特性（必须背）
+| 特性 | 含义 | 解决方案 |
+|------|------|----------|
+| **原子性** | 操作不可分割 | synchronized、Lock、Atomic 类 |
+| **可见性** | 修改对另一线程立即可见 | volatile、synchronized、Lock |
+| **有序性** | 代码按书写顺序执行 | volatile、synchronized |
+
+> **口诀"原可序"**：原子性、可见性、有序性。
+
+### 5. synchronized（必背）
+- Java 内置关键字，保证**原子性最简单可靠**的手段
+- **每个对象底层对应一把监视器锁（Monitor Lock）**
+- 拿不到锁 → 进入 **BLOCKED** 排队；执行完自动释放锁
+- **锁粒度尽量小**（只锁共享数据代码，不锁整个方法）
+
+**三种写法：**
+| 写法 | 锁的是什么 |
+|------|-----------|
+| 同步实例方法 `synchronized void m()` | 当前对象 **this** |
+| 同步静态方法 `static synchronized void m()` | 类的 **Class 对象** |
+| 同步代码块 `synchronized(lock)` | **指定的任意对象**（最灵活） |
+
+**转账场景**："检查-修改"必须整体锁住（`if (balance >= amount)` + `balance -= amount` 用 synchronized(this) 包住）。
+
+## 四、volatile 与 JVM 内存模型（对应 08-11）
+
+### 1. volatile 三大语义（必背）
+1. **可见性**：写 volatile 立即刷主存；读强制从主存读（禁止用 CPU 缓存）
+2. **禁止重排序（有序性）**：volatile 读写及前后指令不重排
+3. **不保证原子性**：`volatile count++` 依旧丢更新——必须用 synchronized/Lock/原子类
+
+### 2. 可见性问题根源（JVM 内存模型）
+- 每线程有**独立工作内存（CPU 缓存）**，读写优先走工作内存
+- 刷新主存有延迟 → main 改 running 为 false，worker 一直读缓存旧值 true → **while 永不退出**
+- volatile 解决"程序永不退出"
+
+### 3. volatile vs synchronized
+| 对比 | volatile | synchronized |
+|------|----------|--------------|
+| 本质 | 轻量、不加锁 | 锁机制（Monitor Lock） |
+| 解决 | 可见性 + 有序性 | **三大特性全部** |
+| 适用 | 标志位 | 复合操作 |
+
+> **验证**：volatile 修饰 count 后 count++ 结果照样 < 1000（只解决可见性）；加 synchronized 后必然 = 1000。
+
+## 五、Lock 锁（对应 08-11）
+
+### 1. ReentrantLock 可重入锁
+**JDK 1.5** 提供 `Lock` 接口 + `ReentrantLock` 实现，比 synchronized 更精细：
+1. **超时等待**（tryLock(timeout)）
+2. **响应中断**（lockInterruptibly()）
+3. **指定公平性**（`new ReentrantLock(true)` 公平锁）
+4. 多条件变量、支持锁读（读写分离）
+
+### 2. 使用铁律（必背）
+> **synchronized 自动释放锁；Lock 必须手动 unlock() 且放 finally**——否则抛异常/return 时锁永不释放 → 死锁。
+
+```java
+lock.lock();
+try { count++; }
+finally { lock.unlock(); }
+```
+
+### 3. 核心方法
+`lock()` / `unlock()` / `tryLock()`（拿不到立即返回 false）/ `tryLock(timeout, unit)`（限时）/ `lockInterruptibly()`（可中断）
+
+### 4. synchronized vs Lock 七维对比（面试常考）
+| 维度 | synchronized | ReentrantLock |
+|------|--------------|---------------|
+| 语法 | 简单（关键字） | 复杂（try-finally） |
+| 释放 | **自动** | **手动 unlock** |
+| 可中断 | 不支持 | 支持 |
+| 超时等待 | 不支持 | 支持 |
+| 锁读 | 不支持 | 支持（读写分离） |
+| 底层 | **监视器锁 Monitor Lock** | **AQS 抽象队列同步器** |
+| JDK21 | 大幅优化 | 性能相近 |
+
+## 六、死锁（对应 08-11）
+
+**概念**：两个或多个线程**相互持有对方所需的资源**，导致等待无法继续。
+
+### 4 个必要条件（缺一不可，必背）
+1. **互斥**：资源同一时刻只能被同一线程占用
+2. **持有且等待**：持有一个资源同时等另一个
+3. **不可剥夺**：已持资源不能强夺，只能自己释放
+4. **循环等待**：你等我、我等你形成环
+
+### 避免死锁 3 方法
+| 方法 | 打破的条件 |
+|------|-----------|
+| **固定锁顺序**（所有线程按相同顺序加锁） | 打破"循环等待" |
+| **tryLock() 超时获取**（拿不到就放弃） | 打破"持有且等待" |
+| **高级并发工具**（如 ConcurrentHashMap） | 从源头避免手动加多把锁 |
+
+> 排查死锁：`jstack` 命令找 `Found one Java-level deadlock`。
+
+## 七、线程池（对应 08-11）
+
+### 1. new Thread().start() 的三个问题（必背）
+1. **创建/销毁开销大**（每线程 1MB 栈内存 + OS 交互）
+2. **线程数量不受控**（高并发耗尽资源崩溃）
+3. **资源利用率低**（任务几毫秒、创建销毁几秒）
+
+**解决方案：【线程复用 + 任务排队 + 动态扩容 + 上限保护】**
+
+### 2. ThreadPoolExecutor 7 个参数（必背）
+| 参数 | 说明 |
+|------|------|
+| corePoolSize | 核心线程数（常驻） |
+| maximumPoolSize | 最大线程数（必须 > 核心） |
+| keepAliveTime | 非核心线程空闲存活时间 |
+| unit | 时间单位 |
+| workQueue | 工作队列 |
+| threadFactory | 线程工厂 |
+| handler | 拒绝策略 |
+
+### 3. 执行流程（必背）
+**核心线程 → 工作队列 → 非核心线程 → 拒绝策略**
+> 线程不够**不先创建新线程**，先放工作队列；**队列满且未达最大线程数**才扩容。
+
+### 4. 拒绝策略
+`AbortPolicy`（默认抛异常）/ `CallerRunsPolicy`（调用者执行）/ `DiscardPolicy`（丢弃）/ `DiscardOldestPolicy`（丢最旧）
+
+### 5. 使用示例
+```java
+ThreadPoolExecutor pool = new ThreadPoolExecutor(
+        3, 5, 60, TimeUnit.SECONDS,
+        new ArrayBlockingQueue<>(10),
+        Executors.defaultThreadFactory(),
+        new ThreadPoolExecutor.AbortPolicy());
+pool.execute(runnable);   // 复用线程，不是 new Thread
+pool.shutdown();          // 关闭线程池
+```
+
+> ⚠️ 线程池解决"创建开销"问题，**不解决"数据竞争"问题**（池中线程处理共享数据仍需锁）。
+
+## 本阶段必须背诵的核心口诀
+
+1. **程序/进程/线程**：硬盘文件 / 内存执行的程序 / 进程中的执行路径
+2. **并行 = 多 CPU 同时；并发 = 单 CPU 交替**
+3. **run() 封装任务、start() 启动线程；实现 Runnable 比继承 Thread 更推荐**
+4. **Callable 有返回值（call）+ FutureTask 包装 + get() 取结果**
+5. **守护线程随用户线程结束；JVM 只有用户线程全结束才退出**
+6. **线程 6 状态**：NEW → RUNNABLE → BLOCKED/WAITING/TIMED_WAITING → TERMINATED（终点）
+7. **线程安全三原因**：多线程 + 共享数据 + 读改写（缺一不可）
+8. **三大特性"原可序"**：原子性→锁/原子类；可见性→volatile/锁；有序性→volatile/synchronized
+9. **volatile 解决可见性+有序性，不保证原子性**
+10. **Lock 必须手动 unlock 放 finally；支持超时/可中断/公平锁**
+11. **死锁 4 条件**：互斥、持有且等待、不可剥夺、循环等待
+12. **线程池 7 参数 + 流程**：核心 → 队列 → 非核心 → 拒绝

复习/JavaSE阶段/阶段07-JVM类加载与反射.md

@@ -0,0 +1,276 @@
+# 阶段七：JVM 类加载与反射 —— 核心知识点总纲
+
+> 本阶段涵盖：**类加载机制与反射、反射 Field 字段反射与 Method 方法反射**
+> 细分文档：`按日细分/20260812-笔记.md`、`按日细分/20260813-笔记.md`
+> 学生需要重点理解、背诵、掌握的理论核心知识点。
+
+---
+
+## 一、类加载机制（对应 08-12）
+
+### 1. Java 程序执行全流程（必背总纲）
+
+```
+.java 源文件 --编译--> .class 字节码 --类加载器--> 内存 --> JVM 解释 --> 二进制机器码 --> 执行
+```
+
+- **`.class` 字节码平台无关** → Java 跨平台原理
+- **类加载器** = 字节码的"搬运工"（把 .class / jar 包加载进内存）
+
+### 2. 类加载的 6 种时机（必背）
+
+| # | 触发场景 | 示例 |
+|---|----------|------|
+| ① | 创建类的实例对象 | `new Demo01()` |
+| ② | 调用 static 方法 | `Math.abs(-1)` |
+| ③ | 访问/赋值 static 变量 | `Student.school = "..."` |
+| ④ | 反射创建 Class 对象 | `Class.forName("...")` |
+| ⑤ | 初始化子类（先加载父类） | `new SubStudent()` |
+| ⑥ | Java.exe 运行主类 | `java course.Demo01` |
+
+> **懒加载原则**：使用时才加载。初始化子类**先触发父类加载**（先父后子）。
+
+### 3. 类的加载过程（3 大步 5 小步，必背）
+
+```
+1. 加载（Loading）：通过全限定名获取字节流 → 生成 java.lang.Class 对象
+2. 链接（Linking）
+    ├── 验证（Verify）：检查字节流符合规范、无安全隐患
+    ├── 准备（Prepare）：为 static 变量分配内存并设默认值（int→0）
+    └── 解析（Resolve）：符号引用 → 直接引用；用到其他类在此查找
+3. 初始化（Initialization）：执行静态变量赋值、静态代码块
+```
+
+**一句话**：加载"搬文件"、验证"查安全"、准备"分默认内存"、解析"找引用的类"、初始化"跑初始化代码"。
+
+### 4. 执行顺序（必背）
+
+**静态代码块（类加载初始化阶段，只执行一次）→ 普通代码块（每次 new，构造前）→ 构造方法**
+
+### 5. 三种类加载器（必背）
+
+| 类加载器 | 职责 | 父加载器 |
+|----------|------|----------|
+| BootstrapClassLoader（启动） | 最核心 JDK 类 | 无（表示为 null） |
+| PlatformClassLoader（平台） | JDK 特殊模块 | Bootstrap |
+| SystemClassLoader（系统） | **用户类路径的类** | Platform |
+
+- **BootstrapClassLoader 由 C/C++ 实现，Java 中表示为 null**；对 null 调 getParent() 空指针
+- 获取：`ClassLoader.getSystemClassLoader()` → 逐级 `getParent()`
+
+### 6. 双亲委派模型（必背）
+
+**概念**：类加载器收到加载请求**不自己先加载**，先委派给父加载器，递归到最顶层；顶层能加载就成功，顶层不行才由子加载器尝试。
+- **委派向上**（子→父→最顶层）；**回退向下**（顶层→子）
+- 核心类（java.lang.String）由顶层加载；用户类由系统类加载器加载
+
+**为什么需要双亲委派（三原因必背）：**
+1. **避免类被重复加载**：同一类全 JVM 只有一个 Class 对象（唯一性 = 类 + 类加载器共同决定）
+2. **保证核心类库安全**：用户写的假 `java.lang.String` 永远不会被加载
+3. **保证类的唯一性**：避免多份 String 类型混乱
+
+### 7. 类加载器加载配置文件（getResourceAsStream + Properties）
+
+```java
+ClassLoader cl = ClassLoader.getSystemClassLoader();
+InputStream in = cl.getResourceAsStream("prop.properties");  // classpath 根目录
+Properties pro = new Properties();
+pro.load(in);
+String driver = pro.getProperty("db.driver");
+in.close();
+```
+
+- **Properties**：父类 Hashtable、Map 实现类；`load()` 加载、`getProperty(key)` 取值
+- 意义：**配置与代码分离**（改配置不用改代码）；DB 四要素 driver/url/username/password
+
+## 二、反射机制（对应 08-12）
+
+### 1. 概念（必背）
+
+**反射是 Java 的运行时动态机制**：运行状态中能获取任意类的所有属性方法（**包括 private**）、调用任意对象的任意属性和方法。反射是 Spring/MyBatis/Hibernate/JDBC 等**框架的基础**。
+
+### 2. 普通调用 vs 反射调用（5 维对比必背）
+
+| 维度 | 普通调用 | 反射调用 |
+|------|---------|---------|
+| 获取信息时机 | 编译期写死 | **运行时动态** |
+| 依赖关系 | 强耦合 | **解耦** |
+| 创建对象 | `new 类名()` | `Class.forName() + newInstance()` |
+| 调用方法 | `对象.方法()` | `method.invoke(对象, 参数)` |
+| 灵活性 | 固定 | 高度灵活 |
+
+### 3. 反射的注意事项（必背）
+
+**日常业务开发尽量不用反射**（像开挂）：①**可能破坏封装性**（能拿 private）②**效率低**（比正常创建低 3~100 倍）。
+> 学习反射的目的：理解框架底层源码 + 架构/中间件做解耦适配。
+
+### 4. 反射工作机制（必背链条）
+
+```
+Person.java → javac → Person.class → 类加载器 → Class 对象（类的类模板）
+    ├── Constructor → newInstance() 创建对象
+    ├── Field → get/set 读写字段
+    └── Method → invoke() 执行方法
+```
+
+### 5. 反射核心类
+
+Class（反射入口）/ Constructor（创建对象）/ Field（读写字段）/ Method（调用方法）/ Modifier（解析修饰符）/ Parameter（方法参数）
+
+### 6. 获取 Class 对象的三种方式（必背）
+
+| 方式 | 写法 | 特点 |
+|------|------|------|
+| 方式一 | `Student.class` | 最直接，编译期类型检查 |
+| 方式二 | `student.getClass()` | Object 方法，需有对象 |
+| 方式三 | `Class.forName("course.Student")` | 字符串传类名**最灵活**，**框架最常用**；写错抛 ClassNotFoundException |
+
+**三个重要验证：**
+1. **殊途同归**：三种方式拿到**同一个对象**（clazz1 == clazz2 == clazz3 全 true）
+2. **基本类型和数组也有 Class 对象**：`int.class == Integer.TYPE`
+3. **类加载时机差异**：`Class.forName()` **会触发静态代码块**；`类名.class` 和 `对象.getClass()` 不触发
+
+**查看类型信息：** `getName()`（全类名）/ `getSimpleName()` / `getSuperclass()` / `getPackage()`
+
+### 7. 反射 Constructor（构造方法）
+
+**4 个获取 API：**
+
+| 方法 | 是否含 private |
+|------|---------------|
+| `getConstructors()` | ❌ 只 public |
+| `getConstructor(Class...)` | ❌ 只 public |
+| `getDeclaredConstructors()` | ✅ 含私有 |
+| `getDeclaredConstructor(Class...)` | ✅ 含私有 |
+
+**暴力反射：** 私有构造直接 `newInstance()` 报权限错，先 **`setAccessible(true)`** 放开权限。
+
+```java
+Constructor<?> dc = studentClass.getDeclaredConstructor(String.class, Integer.class);
+dc.setAccessible(true);
+Object o = dc.newInstance("张三", 1001);
+```
+
+**反射受检异常：** ClassNotFoundException / NoSuchMethodException / InstantiationException / IllegalAccessException / InvocationTargetException
+
+## 三、反射 Field 字段反射（对应 08-13）
+
+### 1. Field 概述
+
+**Field 对象代表类中的一个成员变量。** `get()` 读、`set()` 写。
+> 框架典型应用：ORM 框架把数据库数据映射到 Java 类，**用的就是 Field.set()**（ORM 底层原理）。
+
+### 2. 获取 Field 的 4 个 API（必背）
+
+| 方法 | 含 private | 含父类继承 |
+|------|-----------|-----------|
+| `getFields()` | ❌ | ✅ |
+| `getField(name)` | ❌ | ✅ |
+| `getDeclaredFields()` | ✅ 本类全部 | ❌ |
+| `getDeclaredField(name)` | ✅ | ❌ |
+
+### 3. Field 常用方法（必背）
+
+`get(obj)` 读值 / `set(obj, 值)` 赋值 / `setAccessible(true)` 暴力反射 / `getType()` 类型 / `getName()` 属性名 / `getModifiers()` 修饰符（int，`Modifier.toString()` 解析）
+
+### 4. 操作静态属性（对象参数传 null，必背）
+
+| 场景 | get 参数 | set 参数 | 原因 |
+|------|---------|---------|------|
+| 实例属性 | `get(对象)` | `set(对象, 值)` | 属于某个对象 |
+| **静态属性** | `get(null)` | `set(null, 值)` | **属于整个类** |
+
+### 5. 四个典型操作
+
+```java
+// ① 遍历所有属性，输出修饰符+类型+属性名
+Field[] fields = clazz.getDeclaredFields();
+for (Field f : fields) {
+    System.out.println(Modifier.toString(f.getModifiers()) + " " + f.getType().getSimpleName() + " " + f.getName());
+}
+// ② 操作 public 字段
+Field emailField = clazz.getField("email");
+emailField.get(s);  emailField.set(s, "lisi@qq.com");
+// ③ 操作 private 字段（暴力反射）
+Field nameField = clazz.getDeclaredField("name");
+nameField.setAccessible(true);  nameField.get(s);  nameField.set(s, "李四");
+// ④ 操作 static 字段（传 null）
+Field schoolField = clazz.getDeclaredField("school");
+schoolField.get(null);  schoolField.set(null, "新学校");
+```
+
+## 四、反射 Method 方法反射（对应 08-13）
+
+### 1. Method 概述
+
+**Method 对象代表类中的一个方法。** 反射通过 `Method.invoke(对象, 参数...)` 调用方法，**等价于 `对象.方法(参数)`**——方法名称和参数**运行时才确定**。
+> 应用：动态代理、测试框架（JUnit）、注解解释器、框架调用 setter/getter。
+
+### 2. 获取 Method 的 4 个 API（必背）
+
+| 方法 | 含 private | 含父类/接口继承 |
+|------|-----------|-----------------|
+| `getMethods()` | ❌ | ✅（含 toString/hashCode） |
+| `getMethod(name, parameterTypes)` | ❌ | ✅ |
+| `getDeclaredMethods()` | ✅ 本类全部 | ❌ |
+| `getDeclaredMethod(name, parameterTypes)` | ✅ | ❌ |
+
+**重载方法必须指明参数类型（必背）：**
+
+```java
+getMethod("setName", String.class)   // String.class 用来区分同名重载
+```
+
+> 不写或写错参数类型都抛 `NoSuchMethodException`。
+
+### 3. Method 常用方法（必背）
+
+`invoke(obj, args)` 调用 / `setAccessible(true)` 暴力反射 / `getReturnType()` 返回值类型 / `getParameterTypes()` 参数类型数组 / `getModifiers()` 修饰符
+
+### 4. invoke 的四种调用规律（重点必背）
+
+| 方法类型 | invoke 写法 |
+|----------|-------------|
+| public 实例方法 | `invoke(对象, 参数...)` |
+| **static 静态方法** | `invoke(null, 参数...)` |
+| **void 无返回值方法** | 调用后返回 **null** |
+| **private 私有方法** | 先 `setAccessible(true)` 再 invoke |
+
+## 五、反射知识全景总览（四类知识地图，必背）
+
+### 12 个获取 API 的统一规律（3 组 × 4 个）
+
+| 成员 | 取多个（数组） | 取单个 | 含私有数组 | 含私有单个 |
+|------|---------------|--------|-----------|-----------|
+| 属性 | `getFields()` | `getField(name)` | `getDeclaredFields()` | `getDeclaredField(name)` |
+| 方法 | `getMethods()` | `getMethod(name, 参数类型...)` | `getDeclaredMethods()` | `getDeclaredMethod(name, 参数类型...)` |
+| 构造 | `getConstructors()` | `getConstructor(参数类型...)` | `getDeclaredConstructors()` | `getDeclaredConstructor(参数类型...)` |
+
+> **口诀（贯穿三组）**：**含 `Declared` 的能拿私有（本类全部），不含 `Declared` 的只能拿 public（含父类/接口继承）。**
+
+### 每类反射对象的关键方法
+
+| 类别 | 关注点 | 关键方法 |
+|------|--------|----------|
+| Field 属性 | 属性组成部分 | 名字 getName、修饰符 getModifiers、**值 get/set** |
+| Method 方法 | 方法组成部分 | 名字 getName、**执行 invoke**、返回值 getReturnType、参数 getParameterTypes、修饰符 getModifiers |
+| Constructor 构造 | 构造组成部分 | 修饰符 getModifiers、参数 getParameterTypes、**创建 newInstance** |
+
+### 反射三大成员统一套路（必背）
+
+**`getDeclaredXxx` 拿私有 + `setAccessible(true)` 放开权限 + 执行操作**（Constructor→newInstance / Field→get/set / Method→invoke）；**操作静态成员（属性/方法）对象参数传 null。**
+
+## 本阶段必须背诵的核心口诀
+
+1. **类加载 6 时机 + 懒加载原则**
+2. **加载 → 链接（验证/准备/解析）→ 初始化**（3 大步 5 小步）
+3. **静态代码块 → 代码块 → 构造方法**
+4. **三种类加载器**：系统 → 平台 → 启动（null）
+5. **双亲委派**：委派向上、回退向下；三原因（避免重复加载/核心类安全/保证唯一性）
+6. **反射 = 运行时动态获取类信息 + 动态调用**；从 Class 对象出发（Constructor/Field/Method）
+7. **三种获取 Class**：类名.class / 对象.getClass() / Class.forName()（最灵活、触发静态块）
+8. **Declared 口诀**：含 Declared 拿私有，不含只拿 public
+9. **setAccessible(true) = 暴力反射**（访问私有成员的关键一步）
+10. **invoke 四规律**：实例传对象、静态传 null、void 返回 null、private 先 setAccessible
+11. **反射三件套**：Constructor 建对象 + Field 读写字段 + Method 调用方法
+12. **操作静态成员传 null**（属性/方法统一规律）