# 2026-07-24 JavaSE 课后作业

> **课程内容**：多态（Polymorphism）、多态中的转型（向上转型/向下转型）、instanceof 运算符、抽象类与多态结合、接口多态案例（USB + 笔记本）、内部类（成员内部类/静态成员内部类/局部内部类）
>
> **涉及前序知识**：继承、抽象类、接口、封装、构造方法、方法重写
>
> **提交方式**：在 `提交\姓名\` 目录下创建对应的 Java 源文件
>
> **截止时间**：下次上课前

---

## 📌 本次作业重要说明

### 命名要求

| 项目 | 要求 |
|------|------|
| **包名** | **必须按题目指定的包名创建**（全小写） |
| **类名** | 自由命名，但需**见名知意** |
| **测试类** | 建议命名为 `TestXxx` 或 `XxxTest` |
| **文件名** | 必须与类名一致 |

### 提交目录结构示例

```
提交\
└─ 张三\
    ├─ p1_smarthome\             ← 第 1 题的包
    │   ├─ SmartDevice.java        ← 接口
    │   ├─ Light.java              ← 实现类（特有：调色）
    │   ├─ AirConditioner.java     ← 实现类（特有：定时）
    │   ├─ RobotVacuum.java        ← 实现类（特有：清洁模式）
    │   └─ SmartHomeController.java ← 测试类（多态 + instanceof + 向下转型）
    └─ p2_computer\              ← 第 2 题的包
        ├─ Computer.java           ← 外部类（含内部类）
        └─ TestComputer.java       ← 测试类
```

> ⚠ **注意**：包名必须严格按题目要求书写（全小写），目录结构必须与包结构一致。

---

## 第 1 题：接口多态 + 转型 + instanceof——智能家居控制系统 ⭐⭐⭐

**包名**：`p1_smarthome`

**知识点**：接口定义与实现、接口多态（参数/数组）、向上转型、向下转型、instanceof 运算符、调用实现类特有方法、开闭原则

### 需求说明

开发一个**智能家居控制系统**。不同家电的开关方式和运行逻辑不同，但都遵循统一的控制规范：**打开 → 运行 → 关闭**。此外，每种家电还有**各自的特有功能**（灯可以调色、空调可以定时、扫地机器人有不同清洁模式）。

请使用 **接口多态 + instanceof + 向下转型** 来设计，要求：
- 控制器通过接口类型操作所有设备（多态）
- 通过 `instanceof` 判断设备类型后向下转型，调用特有功能

### 接口设计

#### SmartDevice 接口

| 方法 | 说明 |
|------|------|
| `void turnOn()` | 打开设备 |
| `void doWork()` | 执行工作 |
| `void turnOff()` | 关闭设备 |

### 实现类要求

#### Light 类（灯——实现 SmartDevice）

| 成员 | 说明 |
|------|------|
| 私有属性 | `location`（位置，String，如 "客厅" / "卧室"） |
| 构造方法 | `Light(String location)` |
| 实现 `turnOn()` | 输出 `"xxx 的灯已打开"` |
| 实现 `doWork()` | 输出 `"xxx 的灯照明中..."` |
| 实现 `turnOff()` | 输出 `"xxx 的灯已关闭"` |
| **特有方法** | `void changeColor(String color)` —— 输出 `"xxx 的灯光变为 xxx 色"` |

#### AirConditioner 类（空调——实现 SmartDevice）

| 成员 | 说明 |
|------|------|
| 私有属性 | `roomName`（房间名，String）、`temperature`（温度，int） |
| 构造方法 | `AirConditioner(String roomName, int temperature)` |
| 实现 `turnOn()` | 输出 `"xxx 空调已打开，设定温度：xxx℃"` |
| 实现 `doWork()` | 输出 `"xxx 空调制冷中，当前室温正降至 xxx℃..."` |
| 实现 `turnOff()` | 输出 `"xxx 空调已关闭"` |
| **特有方法** | `void setTimer(int hours)` —— 输出 `"xxx 空调已设置 xxx 小时后自动关闭"` |

#### RobotVacuum 类（扫地机器人——实现 SmartDevice）

| 成员 | 说明 |
|------|------|
| 私有属性 | `model`（型号，String）、`batteryLevel`（电量，int，百分比） |
| 构造方法 | `RobotVacuum(String model, int batteryLevel)` |
| 实现 `turnOn()` | 输出 `"扫地机器人 xxx 已启动，当前电量：xxx%"` |
| 实现 `doWork()` | 输出 `"扫地机器人 xxx 开始清扫地面..."` |
| 实现 `turnOff()` | 输出 `"扫地机器人 xxx 已完成清扫，自动关闭"` |
| **特有方法** | `void startCleaningMode(String mode)` —— 输出 `"扫地机器人 xxx 已切换到 xxx 模式开始清扫"`（mode 如 "强力" / "静音" / "边缘"） |

### 测试类要求

**`SmartHomeController` 类**（测试类，含 main 方法）：

1. **创建设备数组**：创建一个 `SmartDevice[]` 数组，包含至少 5 个设备

   ```java
   SmartDevice light1 = new Light("客厅");
   SmartDevice ac = new AirConditioner("主卧", 26);
   SmartDevice robot = new RobotVacuum("石头T10", 80);
   SmartDevice light2 = new Light("书房");
   SmartDevice ac2 = new AirConditioner("次卧", 24);
   ```

2. **遍历数组，执行通用工作流程**：对每个设备依次调用 `turnOn()` → `doWork()` → `turnOff()`

3. **遍历数组，执行特有功能**：使用 `instanceof` 判断设备类型后向下转型，调用特有方法：
   - 如果是 `Light` → 向下转型 → 调用 `changeColor("暖黄")`
   - 如果是 `AirConditioner` → 向下转型 → 调用 `setTimer(4)`（4 小时）
   - 如果是 `RobotVacuum` → 向下转型 → 调用 `startCleaningMode("强力")`

4. **编写静态方法 `startDevice(SmartDevice device, int seconds)`**：
   - 调用 `device.turnOn()`
   - 输出 `"设备工作中，请等待" + seconds + "秒..."`
   - 调用 `device.doWork()`
   - 使用 `instanceof` 判断类型后向下转型，调用特有方法（与第 3 步逻辑相同）
   - 调用 `device.turnOff()`
   - 在 `main` 中传入不同类型设备调用此方法

### 思考题

1. 方法参数 `SmartDevice device` 能传入哪些类型的对象？调用 `device.changeColor()` 行吗？为什么？
2. 如果新增一个 `SmartSpeaker`（智能音箱）实现 `SmartDevice`，`SmartHomeController` 需要修改哪些代码？是否符合"开闭原则"？
3. 如果将 `SmartDevice` 改为抽象类而不是接口，设计上会有什么不同？还能实现"一个类实现多个规范"吗？

### 预期输出

```
========== 智能家居启动 ==========
客厅的灯已打开
客厅的灯照明中...
客厅的灯已关闭
客厅的灯光变为暖黄色

主卧空调已打开，设定温度：26℃
主卧空调制冷中，当前室温正降至 26℃...
主卧空调已关闭
主卧空调已设置 4 小时后自动关闭

扫地机器人 石头T10 已启动，当前电量：80%
扫地机器人 石头T10 开始清扫地面...
扫地机器人 石头T10 已完成清扫，自动关闭
扫地机器人 石头T10 已切换到 强力 模式开始清扫

书房的灯已打开
书房的灯照明中...
书房的灯已关闭
书房的灯光变为暖黄色

次卧空调已打开，设定温度：24℃
次卧空调制冷中，当前室温正降至 24℃...
次卧空调已关闭
次卧空调已设置 4 小时后自动关闭

========== 测试 startDevice 方法 ==========
客厅的灯已打开
设备工作中，请等待10秒...
客厅的灯照明中...
客厅的灯光变为暖黄色
客厅的灯已关闭
```

> **提示**：
> - 在 `main` 中调用 `startDevice` 时，可以直接传入数组中的元素，如 `controller.startDevice(devices[0], 10);`
> - `instanceof` 判断的是**运行时类型**，不是编译时类型
> - 特有方法只能通过**向下转型**后的子类引用调用，父类/接口引用无法直接调用

### 需求说明

开发一个**智能家居控制系统**。不同家电的开关方式和运行逻辑不同，但都遵循统一的控制规范：**打开 → 运行 → 关闭**。

请使用 **接口多态** 来设计，要求控制器不依赖具体家电类型。

### 类设计

#### SmartDevice 接口

| 方法 | 说明 |
|------|------|
| `void turnOn()` | 打开设备 |
| `void doWork()` | 执行工作 |
| `void turnOff()` | 关闭设备 |

#### Light 类（灯——实现 SmartDevice）

| 成员 | 说明 |
|------|------|
| 私有属性 | `location`（位置，String，如 "客厅" / "卧室"） |
| 构造方法 | `Light(String location)` |
| 实现 `turnOn()` | 输出 `"xxx 的灯已打开"` |
| 实现 `doWork()` | 输出 `"xxx 的灯照明中..."` |
| 实现 `turnOff()` | 输出 `"xxx 的灯已关闭"` |

#### AirConditioner 类（空调——实现 SmartDevice）

| 成员 | 说明 |
|------|------|
| 私有属性 | `roomName`（房间名，String）、`temperature`（温度，int） |
| 构造方法 | `AirConditioner(String roomName, int temperature)` |
| 实现 `turnOn()` | 输出 `"xxx 空调已打开，设定温度：xxx℃"` |
| 实现 `doWork()` | 输出 `"xxx 空调制冷中，当前室温正降至 xxx℃..."` |
| 实现 `turnOff()` | 输出 `"xxx 空调已关闭"` |

#### RobotVacuum 类（扫地机器人——实现 SmartDevice）

| 成员 | 说明 |
|------|------|
| 私有属性 | `model`（型号，String）、`batteryLevel`（电量，int，百分比） |
| 构造方法 | `RobotVacuum(String model, int batteryLevel)` |
| 实现 `turnOn()` | 输出 `"扫地机器人 xxx 已启动，当前电量：xxx%"` |
| 实现 `doWork()` | 输出 `"扫地机器人 xxx 开始清扫地面..."` |
| 实现 `turnOff()` | 输出 `"扫地机器人 xxx 已完成清扫，自动关闭"` |

### 测试类要求

**`SmartHomeController` 类**：

1. **创建设备数组**：`SmartDevice[]` 数组，包含至少 4 个设备

   ```java
   SmartDevice light1 = new Light("客厅");
   SmartDevice ac = new AirConditioner("主卧", 26);
   SmartDevice robot = new RobotVacuum("石头T10", 80);
   SmartDevice light2 = new Light("书房");
   ```

2. **遍历执行工作流程**：对每个设备依次调用 `turnOn()` → `doWork()` → `turnOff()`

3. **编写静态方法** `startDevice(SmartDevice device, int seconds)`：
   - 调用 `device.turnOn()`
   - 输出 `"设备工作中，请等待" + seconds + "秒..."`
   - 调用 `device.doWork()`
   - 调用 `device.turnOff()`
   - 在 `main` 中用不同类型设备调用该方法

### 思考题

1. 方法参数 `SmartDevice device` 可以传入哪些类型的对象？这体现了多态的什么好处？
2. 如果新增 `SmartSpeaker` 实现 `SmartDevice`，控制器需要修改吗？
3. 对比课堂 `NoteBook.useUsb(Usb usb)` 案例，设计思路有什么相似之处？

### 预期输出

```
========== 智能家居启动 ==========
客厅的灯已打开
客厅的灯照明中...
客厅的灯已关闭

主卧空调已打开，设定温度：26℃
主卧空调制冷中，当前室温正降至 26℃...
主卧空调已关闭

扫地机器人 石头T10 已启动，当前电量：80%
扫地机器人 石头T10 开始清扫地面...
扫地机器人 石头T10 已完成清扫，自动关闭

书房的灯已打开
书房的灯照明中...
书房的灯已关闭

========== 测试 startDevice 方法 ==========
客厅的灯已打开
设备工作中，请等待10秒...
客厅的灯照明中...
客厅的灯已关闭
```

---

## 第 2 题：内部类——计算机硬件体系 ⭐⭐⭐

**包名**：`p2_computer`

**知识点**：成员内部类、私有内部类、内部类访问外部类私有成员、外部类通过方法暴露内部类

### 需求说明

一台计算机由多个硬件组成，如 **CPU（处理器）** 和 **内存**。这些硬件**只能作为计算机的一部分存在**，不能脱离计算机单独使用。同时，CPU 有自己的属性和行为，内存也有自己的属性和行为。

请使用 **内部类** 来设计这个计算机硬件体系。

### 类设计

#### Computer 类（外部类）

| 成员 | 说明 |
|------|------|
| 私有属性 | `brand`（品牌，String）、`model`（型号，String） |
| 构造方法 | `Computer(String brand, String model)` |
| 方法 | `void showInfo()` —— 输出 `"计算机：xxx 品牌：xxx"` |
| 方法 | `void startComputer()` —— 输出启动信息，依次调用 CPU 和 Memory 的方法 |
| 方法 | `CPU getCPU()` —— 返回 CPU 对象 |
| 方法 | `Memory getMemory()` —— 返回 Memory 对象 |

#### CPU 内部类（成员内部类——不私有化）

| 成员 | 说明 |
|------|------|
| 私有属性 | `name`（型号，String）、`frequency`（主频，double） |
| 构造方法 | `CPU(String name, double frequency)` |
| 方法 | `void calculate()` —— 输出 `"计算机 xxx xxx 的 CPU xxx（xxx GHz）正在计算..."`（访问外部类私有属性） |
| 方法 | `void showCPUInfo()` —— 输出 `"CPU：xxx，主频：xxx GHz"` |

#### Memory 内部类（私有内部类）

| 成员 | 说明 |
|------|------|
| 私有属性 | `capacity`（容量，int，单位 GB） |
| 构造方法 | `Memory(int capacity)` |
| 方法 | `void readData()` —— 输出 `"内存（xxx GB）正在读取数据..."` |
| 方法 | `void writeData()` —— 输出计算机信息 + `"内存（xxx GB）正在写入数据..."`（调用外部类 `showInfo()`） |

### 测试类要求

**`TestComputer` 类**：

1. 创建 `Computer` 对象（"联想", "ThinkPad X1"），构造方法中创建 CPU（"酷睿 i7", 3.2）和 Memory（16）
2. 调用 `computer.showInfo()`
3. 通过 `computer.getCPU()` 获取 CPU，调用 `showCPUInfo()` 和 `calculate()`
4. 尝试直接创建 `Memory` 对象（应编译报错，验证私有内部类限制）
5. 通过 `computer.getMemory()` 获取 Memory，调用 `readData()` 和 `writeData()`
6. 调用 `computer.startComputer()` 完整启动流程

```java
// 这行应编译报错——Memory 是 Computer 的私有内部类
// Memory mem = new Memory(16);  // ❌
```

### 思考题

1. 为什么 Memory 要设计为 `private` 内部类？如果改为非私有会怎样？
2. CPU 内部类直接访问外部类 `private` 属性，这说明了内部类的什么特点？
3. 如果将 CPU 改为 `static class CPU`，还能直接访问外部类的 `brand` 和 `model` 吗？为什么？

### 预期输出

```
========== 计算机信息 ==========
计算机：ThinkPad X1 品牌：联想

========== 获取 CPU ==========
CPU：酷睿 i7，主频：3.2 GHz
计算机 联想 ThinkPad X1 的 CPU 酷睿 i7（3.2 GHz）正在计算...

========== 获取内存 ==========
内存（16 GB）正在读取数据...
计算机：ThinkPad X1 品牌：联想
内存（16 GB）正在写入数据...

========== 启动计算机 ==========
计算机启动中...
计算机 联想 ThinkPad X1 的 CPU 酷睿 i7（3.2 GHz）正在计算...
内存（16 GB）正在读取数据...
```

---

## 📋 题目总览

| 题号 | 名称 | 核心知识点 | 难度 |
|------|------|-----------|------|
| 第 1 题 | 智能家居控制系统 | 接口多态、向上转型/向下转型、instanceof、调用实现类特有方法、开闭原则 | ⭐⭐⭐ |
| 第 2 题 | 计算机硬件体系 | 成员内部类、私有内部类、内部类访问外部类私有成员 | ⭐⭐⭐ |