feat: 新增20260727内部类进阶练习——静态成员内部类、局部内部类及综合练习

授课代码/c260727/src/homework_0724/p2_myarray/MyArray.java

@@ -0,0 +1,11 @@
+package homework_0724.p2_myarray;
+
+/**
+ * @title MyArray
+ * @description 
+ * @author WanJl 
+ * @version 1.0 
+ * @create 2026/7/27 
+ */
+public class MyArray {
+}

授课代码/c260727/src/homework_0724/p2_myarray/MyArrayTest.java

@@ -0,0 +1,11 @@
+package homework_0724.p2_myarray;
+
+/**
+ * @title MyArrayTest
+ * @description 
+ * @author WanJl 
+ * @version 1.0 
+ * @create 2026/7/27 
+ */
+public class MyArrayTest {
+}

课堂练习题/20260727-内部类练习.md

@@ -0,0 +1,311 @@
+# 2026-07-27 内部类（Inner Class）进阶练习（课堂练习用）
+
+> **说明**：今日习题围绕 **内部类（Inner Class）** 深入展开，重点覆盖 **静态成员内部类**、**局部内部类**，并综合巩固成员内部类、私有内部类的设计原则。共 **3 道练习**，难度递进。
+
+---
+
+## 练习 1：静态成员内部类——电脑硬件升级（显卡与硬盘）⭐⭐
+
+**知识点**：静态成员内部类、`static` 修饰内部类的特点、静态内部类的创建格式、静态内部类与外部类的关系
+
+### 需求说明
+
+在之前的练习中，我们使用 **普通成员内部类** 设计了计算机的 CPU 和内存。这次，我们换成 **静态成员内部类** 来设计电脑的 **显卡（GraphicsCard）** 和 **硬盘（HardDisk）**，体验静态内部类在创建方式和访问权限上的不同。
+
+> 显卡和硬盘同样是计算机的重要部件，但使用 `static` 修饰后，它们可以不依赖外部类实例而独立创建。
+
+### 类设计
+
+#### Computer 类（外部类）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `brand`（品牌，String）、`price`（价格，double） |
+| 构造方法 | `Computer(String brand, double price)` |
+| 方法 | `void showInfo()` —— 输出电脑品牌和价格 |
+| 方法 | `void startComputer()` —— 输出启动信息，调用显卡的 `render()` 和硬盘的 `readData()` |
+
+#### GraphicsCard 类（**静态成员内部类**）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `model`（型号，String）、`vram`（显存，int，单位 GB） |
+| 构造方法 | `GraphicsCard(String model, int vram)` |
+| 方法 | `void render()` —— 输出 `"显卡（xxx，xxx GB）正在渲染画面..."` |
+| 方法 | `void showSpec()` —— 输出 `"显卡规格：xxx，显存：xxx GB"` |
+
+#### HardDisk 类（**静态成员内部类**）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `capacity`（容量，int，单位 GB）、`type`（类型，String，如 "SSD" / "HDD"） |
+| 构造方法 | `HardDisk(int capacity, String type)` |
+| 方法 | `void readData()` —— 输出 `"硬盘（xxx GB，xxx）正在读取数据..."` |
+| 方法 | `void writeData()` —— 输出 `"硬盘（xxx GB，xxx）正在写入数据..."` |
+
+### 测试类要求
+
+**`TestComputer2` 类**：
+
+1. **直接创建显卡对象**：
+   ```java
+   Computer.GraphicsCard gpu = new Computer.GraphicsCard("RTX 4070", 12);
+   ```
+   > 静态内部类 **不需要** 先创建外部类对象，格式为 `外部类名.内部类名`
+
+2. **直接创建硬盘对象**：
+   ```java
+   Computer.HardDisk disk = new Computer.HardDisk(1024, "SSD");
+   ```
+
+3. 调用显卡的 `showSpec()` 和 `render()` 方法
+
+4. 调用硬盘的 `readData()` 和 `writeData()` 方法
+
+5. 创建 `Computer` 对象（"华硕", 8999.0），调用 `startComputer()`
+
+6. **尝试**：在 GraphicsCard 的 `render()` 方法中直接访问外部类的 `brand` 属性——观察是否编译报错
+
+### 思考题
+
+1. 静态内部类和普通成员内部类在 **创建方式** 上有什么区别？从 `new` 的语法角度分析。
+
+2. 静态内部类能否直接访问外部类的 **实例成员**（如 `brand`、`price`）？为什么？
+
+3. 如果确实需要在静态内部类中访问外部类的实例成员，应该如何改造代码？（提示：通过参数传递外部类引用）
+
+4. 对比之前的 CPU（成员内部类）和现在的 GraphicsCard（静态内部类），哪种内部类更适合描述"计算机的部件"这个场景？说说你的理由。
+
+### 预期输出
+
+```
+========== 独立创建显卡 ==========
+显卡规格：RTX 4070，显存：12 GB
+显卡（RTX 4070，12 GB）正在渲染画面...
+
+========== 独立创建硬盘 ==========
+硬盘（1024 GB，SSD）正在读取数据...
+硬盘（1024 GB，SSD）正在写入数据...
+
+========== 启动计算机 ==========
+计算机 华硕 正在启动...
+显卡（RTX 4070，12 GB）正在渲染画面...
+硬盘（1024 GB，SSD）正在读取数据...
+```
+
+---
+
+## 练习 2：局部内部类——网上购物车结算系统 ⭐⭐
+
+**知识点**：局部内部类、局部内部类的作用域、局部内部类访问方法参数和局部变量、effectively final
+
+### 需求说明
+
+在电商购物车结算时，我们需要计算商品的总价、折扣价等。计算逻辑只在该次结算方法中使用，**不需要对外暴露**，因此非常适合设计为 **局部内部类**。
+
+### 类设计
+
+#### ShoppingCart 类（外部类）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `items`（商品名称数组，`String[]`） |
+| 私有属性 | `prices`（单价数组，`double[]`） |
+| 私有属性 | `quantities`（数量数组，`int[]`） |
+| 构造方法 | `ShoppingCart(String[] items, double[] prices, int[] quantities)` —— 三个数组长度应一致 |
+| 方法 | `void checkout(double discountRate)` —— 结算方法，**内部定义局部内部类** 完成计算 |
+| 方法 | `void showCart()` —— 显示购物车中的所有商品信息 |
+
+#### checkout 方法中的局部内部类 `OrderCalculator`
+
+在 `checkout(double discountRate)` 方法内部定义以下局部内部类：
+
+| 成员 | 说明 |
+|------|------|
+| 构造方法 | `OrderCalculator()` —— 可输出 "订单计算器已创建" |
+| 方法 | `double calculateTotal()` —— 遍历商品，计算 `单价 × 数量` 的总和 |
+| 方法 | `double calculateDiscountedTotal(double rate)` —— 调用 `calculateTotal()` 后乘以折扣率 |
+| 方法 | `void printReceipt()` —— 逐行打印每个商品的名称、单价、数量、小计，最后打印总价和折后价 |
+
+### 测试类要求
+
+**`TestShoppingCart` 类**：
+
+1. 准备测试数据：
+   ```java
+   String[] items = {"笔记本", "钢笔",  "橡皮"};
+   double[] prices = {15.5,    5.0,    2.0};
+   int[] quantities = {2,       3,      5};
+   ```
+
+2. 创建 `ShoppingCart` 对象，调用 `showCart()` 显示购物车
+
+3. 调用 `checkout(0.8)` 传入 8 折折扣，观察输出
+
+4. **验证局部内部类的封装性**：尝试在 `main` 方法中直接创建 `OrderCalculator` 对象：
+   ```java
+   // 这行应编译报错 —— OrderCalculator 是局部内部类，仅在 checkout 方法内可见
+   // OrderCalculator calculator = new OrderCalculator();  // ❌
+   ```
+
+### 思考题
+
+1. 局部内部类的作用域是什么？它可以在哪些位置被访问？
+
+2. 在 `OrderCalculator` 中访问了 `checkout` 方法的参数 `discountRate`。从 Java 8 开始，这个参数有什么要求？（提示：effectively final）
+
+3. 如果将 `OrderCalculator` 改成成员内部类，设计上是否合理？为什么？
+
+4. 局部内部类除了可以访问外部类的成员，还能访问什么？
+
+### 预期输出
+
+```
+========== 购物车信息 ==========
+商品清单：
+  笔记本   ¥15.5  × 2  = ¥31.0
+  钢笔     ¥5.0   × 3  = ¥15.0
+  橡皮     ¥2.0   × 5  = ¥10.0
+
+========== 开始结算（折扣率：0.8）==========
+订单计算器已创建
+---------- 购物清单 ----------
+笔记本   ¥15.5  × 2  = ¥31.0
+钢笔     ¥5.0   × 3  = ¥15.0
+橡皮     ¥2.0   × 5  = ¥10.0
+-------------------------------
+商品总价：¥56.0
+折扣后价：¥44.8
+```
+
+---
+
+## 练习 3：综合练习——学校管理系统（成员内部类 + 静态内部类 + 局部内部类）⭐⭐⭐
+
+**知识点**：私有成员内部类、静态成员内部类、局部内部类综合运用、内部类的设计原则
+
+### 需求说明
+
+设计一个 **学校管理系统**，要求使用不同类型的内部类来组织代码：
+
+- **学生（Student）** 是学校的核心成员，应设计为 **私有成员内部类**，只能通过学校对象创建
+- **教师信息（TeacherInfo）** 是学校的公共信息，应设计为 **静态成员内部类**，可独立访问
+- **上课点名（AttendanceRecorder）** 仅在 `holdClass()` 方法中使用，应设计为 **局部内部类**
+
+### 类设计
+
+#### School 类（外部类）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `schoolName`（学校名称，String） |
+| 私有属性 | `address`（地址，String） |
+| 构造方法 | `School(String schoolName, String address)` |
+| 方法 | `void showInfo()` —— 输出学校信息 |
+| 方法 | `Student createStudent(String name, int age, String studentId)` —— **创建并返回学生对象**（因为 Student 是私有的，外界无法直接 new） |
+| 方法 | `void holdClass(TeacherInfo teacher, String course)` —— 上课方法，内部使用 **局部内部类** 记录出勤 |
+| 方法 | `static void showSchoolRule()` —— 输出学校校训（静态方法） |
+
+#### Student 类（**私有成员内部类**）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `name`（姓名，String）、`age`（年龄，int）、`studentId`（学号，String） |
+| 构造方法 | `Student(String name, int age, String studentId)` |
+| 方法 | `void study()` —— 输出 `"学生 xxx（学号：xxx）正在学习..."` |
+| 方法 | `void showInfo()` —— 输出学生完整信息 |
+
+#### TeacherInfo 类（**静态成员内部类**）
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `name`（姓名，String）、`subject`（教授科目，String）、`salary`（工资，double） |
+| 构造方法 | `TeacherInfo(String name, String subject, double salary)` |
+| 方法 | `void teach()` —— 输出 `"教师 xxx 正在教授 xxx..."` |
+| 方法 | `void showInfo()` —— 输出教师信息（含学校名称——思考能否直接访问？） |
+| 静态方法 | `static void showTeacherRule()` —— 输出 `"为人师表，教书育人"` |
+
+#### holdClass 方法中的局部内部类 `AttendanceRecorder`
+
+| 成员 | 说明 |
+|------|------|
+| 私有属性 | `attendedStudents`（出勤学生名单，`String[]`），通过构造方法传入 |
+| 构造方法 | `AttendanceRecorder(String[] attendedStudents)` |
+| 方法 | `void record()` —— 遍历出勤名单，逐行输出 `"✅ xxx 已签到"` |
+| 方法 | `void showSummary()` —— 输出出勤总人数 |
+
+### 测试类要求
+
+**`TestSchool` 类**：
+
+1. **创建 School 对象**（"清华附中", "北京市海淀区"）
+
+2. **通过 School 创建学生**——`Student` 是私有内部类，不能直接 `new`：
+   ```java
+   // Student s = new Student("张三", 18, "2024001");    // ❌ 编译报错——Student 是私有的
+   // ❌ 也无法通过 School.Student 方式创建，因为 private 限制
+   ```
+
+   ```java
+   // ✅ 必须通过 School 的公共方法创建
+   // 假设 School 中有 createStudent 方法
+   ```
+
+3. **直接创建教师对象**——`TeacherInfo` 是静态内部类，且非私有：
+   ```java
+   School.TeacherInfo teacher = new School.TeacherInfo("李老师", "数学", 8000.0);
+   teacher.teach();
+   teacher.showInfo();
+   ```
+
+4. 调用 `holdClass()` 方法上课，传入教师对象和课程名称
+
+5. 调用 `School.showSchoolRule()` 和 `School.TeacherInfo.showTeacherRule()` 静态方法
+
+### 思考题
+
+1. 在本系统中，`Student` 被设计为 `private` 内部类，`TeacherInfo` 没有使用 `private`。根据内部类的设计原则，这样设计是否合理？从"外部类对内部类的控制权"角度分析。
+
+2. 在 `TeacherInfo.showInfo()` 中，如果想要输出学校名称 `schoolName`，能否直接访问？如果不能，应该如何改造代码？（提示：静态内部类不能直接访问外部类的实例成员）
+
+3. `AttendanceRecorder` 作为局部内部类，它的作用范围是什么？如果在 `holdClass` 方法外部创建一个 `AttendanceRecorder` 对象，会发生什么？
+
+4. 对比练习 1 和练习 3 中的静态内部类，总结静态内部类在什么场景下更适用。
+
+### 预期输出
+
+```
+========== 学校信息 ==========
+清华附中（地址：北京市海淀区）
+
+========== 创建学生 ==========
+学生 张三（学号：2024001）正在学习...
+学生 李四（学号：2024002）正在学习...
+
+========== 教师信息 ==========
+教师 李老师 正在教授 数学...
+教师信息：李老师 | 数学 | 工资：8000.0
+—— 所属学校：清华附中
+
+========== 开始上课 ==========
+教师 李老师 正在教授 数学...
+✅ 张三 已签到
+✅ 李四 已签到
+✅ 王五 已签到
+今日出勤人数：3 人
+
+========== 校规校训 ==========
+学校校训：自强不息，厚德载物
+教师守则：为人师表，教书育人
+```
+
+---
+
+## 附：内部类类型对比总结
+
+| 内部类类型 | 修饰符 | 创建格式 | 能否直接访问外部类实例成员 | 适用场景 |
+|-----------|--------|---------|--------------------------|---------|
+| 成员内部类 | 无 / private / public | `外部类.new 内部类()` | ✅ 可以 | 内部细节需依赖外部类实例（如心脏之于人） |
+| 私有成员内部类 | `private` | 通过外部类方法返回 | ✅ 可以 | 不想让外界直接访问，完全由外部类控制 |
+| 静态成员内部类 | `static` | `new 外部类.内部类()` | ❌ 不可以（只能访问静态成员） | 内部类不依赖外部类实例，可独立使用 |
+| 局部内部类 | 非修饰符（方法内定义） | 仅在方法内 `new` | ✅ 可以（且可访问方法局部变量） | 仅在某方法内使用的临时逻辑 |