2026-07-27 内部类（Inner Class）基础练习（课堂练习用）

说明：以下习题围绕今日授课核心内容——内部类（Inner Class） 展开，涵盖成员内部类、私有内部类的设计原则、静态成员内部类、局部内部类、匿名内部类等知识点。

题目分为两部分：随堂练习（内部类基础，7 题）和 进阶练习（综合挑战，3 题）。

第一部分：随堂练习

以下练习围绕内部类的基础概念和用法，由浅入深。

练习 1：内部类入门——汽车与发动机

难度：⭐
知识点：内部类概念、成员内部类定义、内部类访问外部类成员

场景描述：汽车（Car）包含发动机（Engine），发动机是汽车的内部组成部分，离开汽车无法独立存在。发动机有自己的行为（启动、熄火），同时需要知道所属汽车的信息。

Car 类（外部类）：

私有属性：brand（品牌，String）、model（型号，String）
构造方法：Car(String brand, String model)
成员内部类 Engine：
- 普通方法：void start() —— 输出 "发动机启动：{brand} {model} 轰鸣声..."（直接访问外部类的私有属性）
- 普通方法：void stop() —— 输出 "发动机熄火：{brand} {model} 安静了..."
外部类方法：void drive() —— 创建 Engine 对象并调用 start()，然后输出 "{brand} {model} 正在行驶..."，再调用 stop()

测试类 CarTest 要求：

public class CarTest {
    public static void main(String[] args) {
        // 1. 创建 Car 对象
        Car car = new Car("宝马", "X5");
        
        // 2. 调用外部类方法——内部由 Car 自己完成
        car.drive();
        
        // 3. （思考）如果 Engine 不是内部类，而是独立类，
        //    需要如何修改才能让 Engine 访问 Car 的 brand 和 model？
    }
}

预期输出：

发动机启动：宝马 X5 轰鸣声...
宝马 X5 正在行驶...
发动机熄火：宝马 X5 安静了...

思考题：

从上述代码看，内部类访问外部类的私有成员时，是否需要 getter 方法？
如果 Engine 改为私有内部类，外界（如 CarTest）能否直接创建 Engine 对象？
本练习中 Engine 对象的创建是在 Car 的内部方法 drive() 中完成的，这符合「外部类访问内部类必须创建对象」的特点吗？

练习 2：私有内部类设计——人（Person）与心脏（Heart）

难度：⭐⭐
知识点：私有内部类、外部类提供公共方法暴露内部类功能、设计原则

场景描述：人有心脏，心脏离开人体无法独立存在。按照 私有内部类设计原则，心脏应该作为人的私有内部类，外界必须通过人的公共方法才能使用心脏的功能。

Person 类（外部类）：

私有属性：name（姓名，String）
构造方法：Person(String name)
私有内部类 Heart：
- 普通方法：void beat() —— 输出 "{name} 的心脏在跳动：咚咚咚..."（直接访问外部类私有属性）
- 普通方法：void rest() —— 输出 "{name} 的心脏在休息：咚...咚...咚..."
公共方法：void heartbeat() —— 在方法内部创建 Heart 对象并调用 beat() 和 rest()

测试类 PersonTest 要求：

public class PersonTest {
    public static void main(String[] args) {
        // 1. 创建 Person 对象
        Person person = new Person("张三");
        
        // 2. 通过 Person 的公共方法访问心脏功能
        person.heartbeat();
        
        // 3. ❌ 思考：能直接这样创建心脏对象吗？
        //    Person.Heart h = new Person().new Heart();  // 编译能通过吗？为什么？
    }
}

预期输出：

张三 的心脏在跳动：咚咚咚...
张三 的心脏在休息：咚...咚...咚...

请回答以下问题：

将 Heart 类设为 private 的好处是什么？
如果 Person 类想对外提供「获取心脏对象」的能力，应该如何修改代码？（参考课堂笔记中 getHeart() 方法的设计）
如果不使用私有内部类，而是将 Heart 写成一个独立类，让 Person 持有 Heart 成员变量，会有什么弊端？（提示：外界可能跳过 Person 直接创建 Heart 对象）

代码补充挑战：请将 Person 类补充完整：

public class Person {
    private String name;
    
    // 构造方法
    public Person(String name) {
        this.name = name;
    }
    
    // 私有内部类 Heart
    // 请补充代码
    
    
    // 公共方法 heartbeat()
    // 请补充代码
    
    
}

练习 3：静态成员内部类——学校与学生证打印

难度：⭐⭐
知识点：静态成员内部类、静态内部类创建格式、静态内部类与外部类的关系

场景描述：每所学校（School）都有统一格式的学生证（StudentCard），其中包含学校名称和学生的个人信息。学生证的模板格式由学校统一规定（静态内部类），不依赖某个具体的学校对象。

School 类（外部类）：

私有静态属性：schoolName（学校名称，static String）—— 所有学校对象共享
静态代码块：初始化 schoolName 为 "四福科技大学"
静态成员内部类 StudentCard：用 static 修饰
- 私有属性：studentName（学生姓名，String）、studentId（学号，String）
- 构造方法：StudentCard(String studentName, String studentId)
- 普通方法：void showCard() —— 输出学生证信息（学校名称使用外部类的静态属性）

测试类 SchoolTest 要求：

public class SchoolTest {
    public static void main(String[] args) {
        // 1. 创建静态内部类对象——格式：外部类名.内部类名 变量 = new 外部类名.内部类名(...)
        School.StudentCard card1 = new School.StudentCard("张三", "2024001");
        School.StudentCard card2 = new School.StudentCard("李四", "2024002");
        
        // 2. 输出学生证信息
        card1.showCard();
        card2.showCard();
        
        // 3. 思考：创建静态内部类对象时，需不需要先创建 School 对象？为什么？
    }
}

预期输出：

========== 四福科技大学 学生证 ==========
姓名：张三
学号：2024001

========== 四福科技大学 学生证 ==========
姓名：李四
学号：2024002

思考题：

静态内部类和普通成员内部类在创建对象时的格式有什么区别？
静态内部类能否访问外部类的 非静态 成员（如实例变量）？为什么？
如果 schoolName 不是 static 的，上面的代码能否正常运行？应该如何修改？

练习 4：局部内部类——餐厅点餐系统

难度：⭐⭐⭐
知识点：局部内部类、定义在方法内部的类、局部内部类的作用域

场景描述：餐厅（Restaurant）中有多种点餐方式（如堂食、外卖）。每种点餐方式的实现细节（如输出欢迎语、计算价格等）各不相同，且只在点餐方法内部使用，故设计为局部内部类。

Restaurant 类（外部类）：

私有属性：name（餐厅名称，String）
构造方法：Restaurant(String name)
方法 void dineIn() —— 堂食点餐
- 局部内部类 DineInOrder：
- 构造方法：输出 "【堂食】xxx 餐厅欢迎您入座！"（xxx 为餐厅名称）
- 普通方法：void orderFood(String dish) —— 输出 "【堂食】已点餐：{dish}，请稍候..."
- 普通方法：void pay(double amount) —— 输出 "【堂食】支付：{amount} 元，感谢惠顾！"
- 在 dineIn() 方法内创建 DineInOrder 对象，调用 orderFood("红烧肉") 和 pay(68.0)
方法 void takeout() —— 外卖点餐
- 局部内部类 TakeoutOrder：
- 构造方法：输出 "【外卖】感谢您选择 xxx 餐厅！"（xxx 为餐厅名称）
- 普通方法：void orderFood(String dish) —— 输出 "【外卖】已接单：{dish}，正在准备..."
- 普通方法：void pay(double amount) —— 输出 "【外卖】在线支付：{amount} 元，等待配送..."
- 在 takeout() 方法内创建 TakeoutOrder 对象，调用 orderFood("宫保鸡丁") 和 pay(38.0)

测试类 RestaurantTest 要求：

public class RestaurantTest {
    public static void main(String[] args) {
        Restaurant restaurant = new Restaurant("幸福小馆");
        
        // 堂食
        restaurant.dineIn();
        System.out.println();
        
        // 外卖
        restaurant.takeout();
        
        // 思考：在外界能否直接创建 DineInOrder 或 TakeoutOrder 对象？为什么？
    }
}

预期输出：

【堂食】幸福小馆 餐厅欢迎您入座！
【堂食】已点餐：红烧肉，请稍候...
【堂食】支付：68.0 元，感谢惠顾！

【外卖】感谢您选择 幸福小馆 餐厅！
【外卖】已接单：宫保鸡丁，正在准备...
【外卖】在线支付：38.0 元，等待配送...

思考题：

局部内部类的作用范围是什么？方法外部能否访问？
局部内部类除了可以访问外部类的成员，还可以访问所在方法内的 局部变量。请在 dineIn() 方法中添加一个局部变量 String welcome = "欢迎光临";，尝试在 DineInOrder 内部类中访问它，观察是否能编译通过。
局部内部类和成员内部类在使用场景上有什么本质区别？

练习 5：匿名内部类入门——多态接收方式（USB 设备 + 计算器）

难度：⭐⭐
知识点：匿名内部类概念、使用前提、语法格式、多态接收（变量赋值）

场景描述：不使用独立的实现类，直接通过匿名内部类创建 USB 设备和计算器对象。匿名内部类的本质是 继承了某个类或实现了某个接口的子类的匿名对象，通过多态接收赋值给父类/接口类型的变量。

5.1 基于接口的匿名内部类（Usb）

参考课堂 Usb 接口和 Demo01.java，使用匿名内部类创建 USB 设备。

Usb 接口（复用课堂代码）：

抽象方法：void startUsb() —— 启动设备
抽象方法：void closeUsb() —— 关闭设备

要求：

public class DemoTest {
    public static void main(String[] args) {
        // 1. 使用匿名内部类创建 Usb 对象（鼠标）
        //    提示：Usb usb = new Usb() { ... };
        //    请补充代码：
        Usb usb = ;
        usb.startUsb();
        usb.closeUsb();
        
        System.out.println();
        
        // 2. 再创建一个 Usb 匿名内部类对象（键盘）
        //    输出："键盘已连接，USB 接口启动"
        //    输出："键盘已断开，USB 接口关闭"
        //    请补充代码：
        
    }
}

预期输出：

鼠标已连接，USB 接口启动
鼠标已断开，USB 接口关闭

键盘已连接，USB 接口启动
键盘已断开，USB 接口关闭

5.2 基于抽象类的匿名内部类（Compute）

参考课堂 Compute 抽象类，使用匿名内部类实现加法计算器。

Compute 抽象类（复用课堂代码）：

抽象方法：int add(int a, int b) —— 两数相加

要求：

// 使用匿名内部类创建 Compute 对象，实现加法计算
Compute compute = new Compute() {
    // 请补充代码
};
int result = compute.add(10, 20);
System.out.println("10 + 20 = " + result);

预期输出：

10 + 20 = 30

思考题

匿名内部类的前提条件是什么？为什么必须存在一个类或接口？
匿名内部类的本质是什么？它的 .class 文件名会是什么样子的？
语法格式中最后的分号 ; 能否省略？为什么？
匿名内部类和之前学的局部内部类有什么区别？

练习 6：匿名内部类做方法参数——餐具 + USB 设备（开发中最常用方式）

难度：⭐⭐⭐
知识点：匿名内部类作为方法参数传递、减少独立实现类文件、开发中最常用

场景描述：在开发中，如果某个接口的实现类只想在当前场景使用一次，不想被其他人复用，可以直接在方法参数位置创建匿名内部类，避免创建独立的实现类文件。本练习通过「餐具使用」和「USB 设备接入」两个场景来练习这种最常用的方式。

6.1 Person 吃饭使用餐具

参考课堂 Tableware 接口、Person 类和 Test02.java。

Tableware 接口（复用课堂代码）：

抽象方法：void openTableware() —— 打开餐具
抽象方法：void useTableware() —— 使用餐具

Person 类（复用课堂代码）：

public class Person {
    /**
     * 吃饭
     * @param tableware 吃饭使用的餐具
     */
    public void eat(Tableware tableware) {
        tableware.openTableware();
        tableware.useTableware();
        System.out.println("开始干饭......");
    }
}

要求：

public class EatTest {
    public static void main(String[] args) {
        Person person = new Person();
        
        // 方式一：先创建匿名内部类对象，再传入方法
        // 请补充代码：创建 Tableware 的匿名内部类（一次性筷子）
        Tableware tableware = ;  // 补全
        person.eat(tableware);
        
        System.out.println();
        
        // 方式二（推荐）：直接在方法参数中创建匿名内部类（一次性勺子）
        // 这种写法更紧凑，开发中最常用！
        person.eat(/* 请在此位置直接创建 Tableware 的匿名内部类 */);
    }
}

预期输出：

打开一次性筷子
使用一次性筷子
开始干饭......

打开一次性勺子
使用一次性勺子
开始干饭......

6.2 NoteBook 接入 USB 设备

参考课堂 NoteBook 类和 Test01.java。

NoteBook 类（复用课堂代码）：

public class NoteBook {
    public void useUSB(Usb usb) {
        usb.startUsb();
        usb.closeUsb();
    }
}

要求：不创建任何独立的实现类，完全使用匿名内部类完成以下操作。

public class NoteBookTest {
    public static void main(String[] args) {
        NoteBook nb = new NoteBook();
        
        // 1. 使用方式一：多态接收 + 传入方法
        //    创建 Usb 匿名内部类（U盘）
        //    输出："U盘已插入，正在读取数据..."
        //    输出："U盘已安全弹出"
        // 请补充代码
        
        
        // 2. 使用方式二（推荐）：直接作为参数传递
        //    直接在 useUSB() 参数中创建 Usb 匿名内部类（移动硬盘）
        //    输出："移动硬盘已连接，传输速率 5Gbps"
        //    输出："移动硬盘已断开连接"
        nb.useUSB(/* 请在此直接创建匿名内部类 */);
        
        System.out.println();
        
        // 3. 尝试接入第三个设备（摄像头），同样使用匿名内部类
        nb.useUSB(/* 请在此直接创建匿名内部类 */);
    }
}

预期输出：

U盘已插入，正在读取数据...
U盘已安全弹出

移动硬盘已连接，传输速率 5Gbps
移动硬盘已断开连接

摄像头已启动，正在捕获画面...
摄像头已关闭，停止录制

思考题

使用匿名内部类作为方法参数有什么好处？（对比先创建独立实现类再传入的方式）
什么场景下适合使用匿名内部类？什么场景下应该创建独立的实现类？
如果 Tableware 接口有 5 个抽象方法，使用匿名内部类实现时有何感受？这说明了什么设计原则？

练习 7：匿名内部类三种使用方式对比——多功能计算器

难度：⭐⭐⭐
知识点：匿名内部类的三种使用方式对比、匿名对象直接调用、特有方法

场景描述：通过一个多功能计算器案例，对比匿名内部类的三种使用方式。理解它们各自的适用场景和优缺点。

Calculator 接口：

抽象方法：int add(int a, int b) —— 加法
抽象方法：int subtract(int a, int b) —— 减法

AdvCalculator 抽象类：

抽象方法：int multiply(int a, int b) —— 乘法
抽象方法：int divide(int a, int b) —— 除法
普通方法：void showInfo() —— 输出 "高级计算器"
特有方法：void reset() —— 输出 "计算器已重置"（注意：这是一个普通方法，不是抽象方法）

要求：完成以下测试类，对比三种方式。

public class CalculatorTest {
    public static void main(String[] args) {
        // ============ 方式一：多态接收（变量赋值） ============
        // 特点：变量可重复使用，但只能调用父类/接口中声明的方法
        // 要求：创建 Calculator 接口的匿名内部类，实现加法和减法
        
        Calculator calc = new Calculator() {
            // 请补充实现
        };
        System.out.println("加法：" + calc.add(30, 12));      // 42
        System.out.println("减法：" + calc.subtract(30, 12)); // 18
        // calc.reset();  // ❌ 思考：这行能编译通过吗？为什么？
        
        System.out.println();
        
        // ============ 方式二：作为方法参数传递 ============
        // 特点：最常用，代码紧凑，适合一次性使用
        // 要求：定义一个 useCalculator 方法，接收 Calculator 参数，
        //       调用 add 和 subtract 并输出结果
        
        useCalculator(new Calculator() {
            // 请补充实现（计算 100 + 200 和 100 - 200）
        });
        
        System.out.println();
        
        // ============ 方式三：匿名对象直接调用 ============
        // 特点：可以调用匿名内部类中定义的特有方法
        // 要求：创建 AdvCalculator 抽象类的匿名内部类，并直接调用方法
        
        // 在匿名内部类中重写 multiply() 和 divide()
        // 同时定义一个特有方法：void showMemory() —— 输出 "内存已清空"
        // 然后通过匿名对象直接调用 multiply()、divide()、showMemory()
        
        new AdvCalculator() {
            // 请补充代码
        }. /* 直接调用方法 */;
    }
    
    // 方式二的辅助方法
    public static void useCalculator(Calculator calc) {
        System.out.println("使用计算器：");
        System.out.println("加法结果：" + calc.add(100, 200));
        System.out.println("减法结果：" + calc.subtract(100, 200));
        System.out.println("计算完毕！");
    }
}

预期输出

============ 方式一：多态接收 ============
加法：42
减法：18

============ 方式二：方法参数 ============
使用计算器：
加法结果：300
减法结果：-100
计算完毕！

============ 方式三：匿名对象直接调用 ============
乘法：15 x 8 = 120
除法：15 ÷ 8 = 1
内存已清空

对比总结填空

请根据以上三种方式，完成下面的对比表格：

对比维度	方式一：多态接收	方式二：方法参数	方式三：匿名对象直接调用
能否重复使用	①______	不能（一次性）	②______
能否调用特有方法	③______	④______	⑤______
开发中使用频率	较少	⑥______	极少
典型代码结构	`接口变量 = new 接口(){}.方法`	`方法名(new 接口(){})`	`new 接口(){}.方法()`

第二部分：进阶练习

以下为综合挑战题，融合多种内部类类型、内部类访问规则、设计原则等知识点。

第 1 题：综合应用——计算机与外设（成员内部类 + 静态内部类）⭐⭐⭐⭐

需求说明

模拟计算机（Computer）的组成结构。计算机包含：

CPU —— 计算机的核心处理部件，每台计算机有自己的 CPU，CPU 的行为与具体的计算机相关（成员内部类）
USB 接口规范 —— 所有计算机的 USB 接口规范是统一的，不依赖具体的计算机实例（静态内部类）
内存条 —— 计算机的内存，可更换升级（普通成员内部类，但设计为私有）

类设计

Computer 类（外部类）：

私有属性：

属性	类型	说明
`brand`	String	品牌
`model`	String	型号
`ram`	Memory	内存条对象（内部类）

构造方法：Computer(String brand, String model, int ramSize) —— 初始化品牌、型号，并创建 Memory 对象（内存大小为 ramSize GB）

内部类 1：CPU（成员内部类，非私有）

CPU 类（成员内部类）：

私有属性：cores（核心数，int）、frequency（主频，double，单位 GHz）
构造方法：CPU(int cores, double frequency)
普通方法：void process() —— 输出 "{brand} {model} CPU 正在计算：{cores} 核 {frequency}GHz 全速运行..."（访问外部类私有属性）

内部类 2：UsbSpec（静态成员内部类）

UsbSpec 类（静态成员内部类）：

静态常量：USB_VERSION = "3.0"（String）
静态常量：MAX_SPEED = "5Gbps"（String）
静态方法：void showSpec() —— 输出 "USB 接口规范：版本 {USB_VERSION}，最大速度 {MAX_SPEED}"
普通方法：void connectDevice(String deviceName) —— 输出 "已连接 {deviceName}，使用 USB {USB_VERSION} 协议传输数据"

内部类 3：Memory（私有成员内部类）

Memory 类（私有成员内部类）：

私有属性：size（容量，int，单位 GB）
构造方法：Memory(int size)
普通方法：void loadData() —— 输出 "{brand} {model} 正在加载数据到内存（{size}GB）..."

外部类方法

方法	说明
`void startUp()`	启动计算机：创建 CPU 对象（4 核，3.2GHz），调用 CPU 的 `process()` 方法，再调用 `Memory` 的 `loadData()` 方法
`void replaceMemory(int newSize)`	更换内存条：重新创建 `Memory` 对象，输出 `"内存已升级为 {newSize}GB"`
`CPU getCpu()`	获取 CPU 对象（返回 CPU 类型，演示外部类返回内部类对象）

测试类要求

ComputerTest 类：

public class ComputerTest {
    public static void main(String[] args) {
        // 1. 创建 Computer 对象（品牌：联想，型号：ThinkPad，内存：16GB）
        Computer computer = new Computer("联想", "ThinkPad", 16);
        
        // 2. 启动计算机
        computer.startUp();
        System.out.println();
        
        // 3. 更换内存（升级到 32GB）
        computer.replaceMemory(32);
        System.out.println();
        
        // 4. 使用静态内部类 UsbSpec
        //    4.1 调用静态内部类的静态方法（无需创建对象）
        Computer.UsbSpec.showSpec();
        System.out.println();
        
        //    4.2 创建静态内部类对象，调用普通方法
        Computer.UsbSpec usb = new Computer.UsbSpec();
        usb.connectDevice("移动硬盘");
        usb.connectDevice("键盘");
        System.out.println();
        
        // 5. 通过外部类方法获取 CPU 对象（演示外部类返回内部类对象）
        Computer.CPU cpu = computer.getCpu();
        cpu.process();
    }
}

预期输出

联想 ThinkPad CPU 正在计算：4 核 3.2GHz 全速运行...
联想 ThinkPad 正在加载数据到内存（16GB）...

内存已升级为 32GB

USB 接口规范：版本 3.0，最大速度 5Gbps

已连接 移动硬盘，使用 USB 3.0 协议传输数据
已连接 键盘，使用 USB 3.0 协议传输数据

联想 ThinkPad CPU 正在计算：4 核 3.2GHz 全速运行...

思考题

本练习中为什么 UsbSpec 设计为 静态内部类？USB 接口规范和具体的计算机实例有关吗？
为什么 Memory 设计为 私有内部类？外界可以直接更换内存吗？（提示：通过 replaceMemory() 方法）
成员内部类 CPU 没有被 private 修饰，外界可以直接创建 Computer.CPU 对象吗？如果可以，创建格式是什么？
如果将 UsbSpec 改为普通成员内部类（去掉 static），创建 UsbSpec 对象的格式会变成什么样？

第 2 题：综合应用——银行账户系统（私有内部类 + 局部内部类 + 静态内部类）⭐⭐⭐⭐⭐

需求说明

模拟银行账户系统。一个银行（Bank）管理多个账户（Account），每个账户包含交易记录（Transaction）。要求：

账户作为银行的 私有成员内部类 —— 外界不能直接创建账户对象，必须通过银行创建
交易记录 作为账户方法的 局部内部类 —— 只在存款/取款方法内部使用
利率信息 作为银行的 静态内部类 —— 所有银行共享利率规范

类设计

Bank 类（外部类）：

私有静态属性：

属性	类型	说明
`bankName`	String	银行名称（静态）

静态代码块：初始化 bankName = "四福银行"

私有成员内部类 Account：

私有属性：accountId（账号，String）、holderName（户主姓名，String）、balance（余额，double）
构造方法：Account(String accountId, String holderName, double initialBalance)
方法 void deposit(double amount) —— 存款
- 方法内部定义 局部内部类 DepositTransaction：
- 构造方法：无参，输出 "【存款交易】开始..."
- 方法：void execute() —— 增加余额，输出 "{holderName} 存入 {amount} 元，余额：{balance} 元（银行：{bankName}）"（注意：局部内部类可访问外部类所有成员，也可访问所在方法的局部变量 amount）
- 方法内部创建 DepositTransaction 对象并调用 execute()
方法 void withdraw(double amount) —— 取款
- 如果余额不足，输出 "取款失败：{holderName} 余额不足（当前余额：{balance} 元）"
- 否则，方法内部定义 局部内部类 WithdrawTransaction：
- 构造方法：无参，输出 "【取款交易】开始..."
- 方法：void execute() —— 减少余额，输出 "{holderName} 取出 {amount} 元，余额：{balance} 元"
- 余额足够时创建 WithdrawTransaction 对象并调用 execute()

方法 Account openAccount(String holderName, double initialBalance) —— 开户

自动生成账号（格式："AC" + System.currentTimeMillis()）
创建 Account 对象并返回
输出 "开户成功！欢迎 {holderName} 成为 {bankName} 的客户"

静态内部类 RateInfo：

静态常量：SAVING_RATE = 0.025（年利率 2.5%）
静态常量：LOAN_RATE = 0.045（贷款利率 4.5%）
静态方法：void showRate() —— 输出利率信息
普通方法：double calculateInterest(double principal, int years) —— 计算存款利息（复利：principal * Math.pow(1 + SAVING_RATE, years) - principal）

测试类要求

BankTest 类：

public class BankTest {
    public static void main(String[] args) {
        // 1. 查看银行利率（静态内部类的静态方法）
        Bank.RateInfo.showRate();
        System.out.println();
        
        // 2. 创建利率计算器对象（静态内部类）
        Bank.RateInfo calculator = new Bank.RateInfo();
        double interest = calculator.calculateInterest(10000, 3);
        System.out.println("1 万元存 3 年，利息：" + String.format("%.2f", interest) + " 元");
        System.out.println();
        
        // 3. 到银行开户
        Bank bank = new Bank();
        // 注意：openAccount 返回的是 Bank.Account 类型（私有内部类），
        // 但因为 Account 是 private 的，这里需要思考怎么接收返回值？
        // 提示：可以用 var（Java 10+）或 Object 类型接收，或者让 Bank 提供其他方法来操作账户
        
        // ❓ 问题：由于 Account 是私有内部类，BankTest 中无法声明 Bank.Account 类型的变量！
        // 那么应该如何设计 Bank 类，让外界能够操作账户？
        //
        // 提示方案：
        // 方案 A：在 Bank 中存储账户，并提供存款/取款的公共方法（通过账号索引）
        // 方案 B：定义一个接口，让 Account 实现该接口，Bank 返回接口类型
        //
        // 请选择一种方案完成设计，并在测试类中完成以下操作：
        //   - 张三开户，存入 5000 元
        //   - 张三存款 2000 元
        //   - 张三取款 1000 元
        //   - 张三尝试取款 10000 元（余额不足）
    }
}

思考与设计挑战

本题的关键在于：私有内部类 Account 的类型在外界不可见，如何让外界操作账户？

请选择以下方案之一完成设计：

方案 A（推荐）：在 Bank 类中使用数组或集合存储账户，对外提供 deposit(String accountId, double amount) 和 withdraw(String accountId, double amount) 等公共方法，外界通过账号来操作。

方案 B：定义一个 Accountable 接口（包含 deposit、withdraw 方法），让 Account 实现该接口，openAccount() 方法返回 Accountable 类型。

预期输出（方案 A 参考）

========== 四福银行 利率信息 ==========
储蓄年利率：2.5%
贷款年利率：4.5%

1 万元存 3 年，利息：768.91 元

========== 开户与交易 ==========
开户成功！欢迎 张三 成为 四福银行 的客户
【存款交易】开始...
张三 存入 5000.0 元，余额：5000.0 元（银行：四福银行）
【存款交易】开始...
张三 存入 2000.0 元，余额：7000.0 元（银行：四福银行）
【取款交易】开始...
张三 取出 1000.0 元，余额：6000.0 元
取款失败：张三 余额不足（当前余额：6000.0 元）

思考题

为什么 Account 设计为 Bank 的私有内部类？这体现了什么设计原则？（参考课堂笔记中 Heart 私有化的原因）
局部内部类 DepositTransaction 和 WithdrawTransaction 为什么定义在方法内部，而不是定义为成员内部类？
静态内部类 RateInfo 中的 showRate() 是静态方法，不需要创建对象就能调用；而 calculateInterest() 是普通方法，需要创建对象才能调用。这两种方式分别适用于什么场景？
如果去掉 RateInfo 的 static 修饰，上面的代码中 Bank.RateInfo.showRate() 还能编译通过吗？new Bank.RateInfo() 还能编译通过吗？

第 3 题：综合应用——学生信息管理系统（匿名内部类 + 排序 + 筛选 + 接口回调）⭐⭐⭐⭐⭐

需求说明

开发一个学生信息管理系统，使用 Student 实体类，通过 匿名内部类 实现多种排序和筛选逻辑。重点练习匿名内部类作为方法参数传递的典型应用（策略模式雏形）。

要求：

不创建任何 StudentComparator 或 StudentFilter 的实现类
所有比较逻辑和筛选逻辑全部使用 匿名内部类 实现
体验「行为参数化」的思想——将行为（排序/筛选）作为参数传递给方法

类设计

Student 类（参考课堂 Student 类，增加 score 属性）：

public class Student {
    private String id;      // 学号
    private String name;    // 姓名
    private Integer age;    // 年龄
    private Double score;   // 成绩

    // 构造方法：Student(String id, String name, Integer age, Double score)
    // getter/setter
    // toString() 返回格式：Student{id='xxx', name='xxx', age=xx, score=xx}
}

需要自行定义的接口：

Comparator 接口（比较器）：

抽象方法：int compare(Student s1, Student s2)
返回负数表示 s1 < s2，返回正数表示 s1 > s2，返回 0 表示相等

Filter 接口（筛选器）：

抽象方法：boolean accept(Student student)
返回 true 表示保留该学生，false 表示过滤掉

StudentManager 类（业务类，由学生自行实现）：

方法	说明
`void sortStudents(Student[] students, Comparator comparator)`	使用冒泡排序按指定比较器对学生数组排序
`void printStudents(Student[] students)`	遍历输出所有学生信息
`Student[] filterStudents(Student[] students, Filter filter)`	按指定条件筛选学生，返回筛选后的新数组
`Student findMax(Student[] students, Comparator comparator)`	按指定比较器查找「最大」学生

测试类要求

StudentSystemTest 类：创建至少 6 个学生对象，放入数组，然后使用匿名内部类完成以下操作：

public class StudentSystemTest {
    public static void main(String[] args) {
        // 1. 创建学生数组
        Student[] students = new Student[]{
            new Student("S001", "张三", 20, 85.5),
            new Student("S002", "李四", 22, 92.0),
            new Student("S003", "王五", 19, 76.5),
            new Student("S004", "赵六", 21, 88.0),
            new Student("S005", "孙七", 23, 95.5),
            new Student("S006", "周八", 20, 68.0)
        };

        StudentManager manager = new StudentManager();

        System.out.println("========== 原始学生信息 ==========");
        manager.printStudents(students);

        // ========== 任务 1：按成绩从高到低排序 ==========
        // 使用匿名内部类实现 Comparator 接口（成绩降序）
        manager.sortStudents(students, new Comparator() {
            // 请补充代码
        });
        System.out.println("\n========== 任务 1：按成绩从高到低排序 ==========");
        manager.printStudents(students);

        // ========== 任务 2：按年龄从小到大排序 ==========
        // 使用匿名内部类实现 Comparator 接口（年龄升序）
        // 请补充代码


        // ========== 任务 3：按姓名长度从短到长排序 ==========
        // 提示：s1.getName().length() - s2.getName().length()
        // 使用匿名内部类实现 Comparator 接口
        // 请补充代码


        // ========== 任务 4：筛选成绩 >= 85 的优秀学生 ==========
        // 使用匿名内部类实现 Filter 接口
        Student[] excellentStudents = manager.filterStudents(students, new Filter() {
            // 请补充代码
        });
        System.out.println("\n========== 任务 4：筛选成绩 >= 85 的优秀学生 ==========");
        manager.printStudents(excellentStudents);

        // ========== 任务 5：筛选年龄 > 20 的学生 ==========
        // 使用匿名内部类实现 Filter 接口
        // 请补充代码


        // ========== 任务 6：查找成绩最高的学生 ==========
        // 使用匿名内部类实现 Comparator 接口，配合 findMax() 方法
        Student topStudent = manager.findMax(students, new Comparator() {
            // 请补充代码
        });
        System.out.println("\n========== 任务 6：成绩最高的学生 ==========");
        System.out.println(topStudent);
    }
}

预期输出（参考）

========== 原始学生信息 ==========
Student{id='S001', name='张三', age=20, score=85.5}
Student{id='S002', name='李四', age=22, score=92.0}
Student{id='S003', name='王五', age=19, score=76.5}
Student{id='S004', name='赵六', age=21, score=88.0}
Student{id='S005', name='孙七', age=23, score=95.5}
Student{id='S006', name='周八', age=20, score=68.0}

========== 任务 1：按成绩从高到低排序 ==========
Student{id='S005', name='孙七', age=23, score=95.5}
Student{id='S002', name='李四', age=22, score=92.0}
Student{id='S004', name='赵六', age=21, score=88.0}
Student{id='S001', name='张三', age=20, score=85.5}
Student{id='S003', name='王五', age=19, score=76.5}
Student{id='S006', name='周八', age=20, score=68.0}

========== 任务 2：按年龄从小到大排序 ==========
Student{id='S003', name='王五', age=19, score=76.5}
Student{id='S001', name='张三', age=20, score=85.5}
Student{id='S006', name='周八', age=20, score=68.0}
Student{id='S004', name='赵六', age=21, score=88.0}
Student{id='S002', name='李四', age=22, score=92.0}
Student{id='S005', name='孙七', age=23, score=95.5}

========== 任务 3：按姓名长度排序 ==========
Student{id='S003', name='王五', age=19, score=76.5}
Student{id='S002', name='李四', age=22, score=92.0}
Student{id='S001', name='张三', age=20, score=85.5}
Student{id='S004', name='赵六', age=21, score=88.0}
Student{id='S005', name='孙七', age=23, score=95.5}
Student{id='S006', name='周八', age=20, score=68.0}

========== 任务 4：筛选成绩 >= 85 的优秀学生 ==========
Student{id='S001', name='张三', age=20, score=85.5}
Student{id='S002', name='李四', age=22, score=92.0}
Student{id='S004', name='赵六', age=21, score=88.0}
Student{id='S005', name='孙七', age=23, score=95.5}

========== 任务 5：筛选年龄 > 20 的学生 ==========
Student{id='S002', name='李四', age=22, score=92.0}
Student{id='S004', name='赵六', age=21, score=88.0}
Student{id='S005', name='孙七', age=23, score=95.5}

========== 任务 6：成绩最高的学生 ==========
Student{id='S005', name='孙七', age=23, score=95.5}

代码补充挑战

请补全 StudentManager 类中的 sortStudents 方法：

public void sortStudents(Student[] students, Comparator comparator) {
    // 使用冒泡排序
    for (int i = 0; i < students.length - 1; i++) {
        for (int j = 0; j < students.length - 1 - i; j++) {
            // 如果 students[j] > students[j+1]（根据 comparator 判断），则交换
            // 提示：if (comparator.compare(students[j], students[j+1]) > 0) { 交换 }
            // 请补充代码

        }
    }
}

思考题

本练习中，排序和筛选的逻辑是通过什么方式传入方法的？这体现了什么设计思想？
如果不用匿名内部类，每次排序都需要创建一个独立的实现类（如 ScoreComparator、AgeComparator 等），会有什么弊端？
Comparator 接口的 compare() 方法返回负数、零、正数分别代表什么含义？
本练习的做法与 Java 标准库中的 Comparator<T> 接口和 Collections.sort() 方法有什么相似之处？
如果将来想按「成绩相同则按年龄排序」这种复合条件排序，需要修改哪些代码？

📋 题目总览

序号	所属部分	核心知识点	难度
练习 1	随堂	成员内部类概念、内部类访问外部类成员	⭐
练习 2	随堂	私有内部类设计原则、外部类提供公共方法暴露内部类功能	⭐⭐
练习 3	随堂	静态成员内部类、创建格式、与外部类的关系	⭐⭐
练习 4	随堂	局部内部类、定义在方法内部、作用域限制	⭐⭐⭐
练习 5	随堂	匿名内部类入门、多态接收方式、基于接口/抽象类	⭐⭐
练习 6	随堂	匿名内部类作为方法参数传递（开发中最常用方式）	⭐⭐⭐
练习 7	随堂	匿名内部类三种使用方式对比、匿名对象直接调用	⭐⭐⭐
进阶 1	进阶	成员内部类 + 静态内部类 + 私有内部类综合运用	⭐⭐⭐⭐
进阶 2	进阶	私有内部类 + 局部内部类 + 静态内部类 + 设计模式综合	⭐⭐⭐⭐⭐
进阶 3	进阶	匿名内部类 + 接口回调 + 排序/筛选策略模式（学生管理系统）	⭐⭐⭐⭐⭐

20260727-内部类练习.md 40 KB History Raw

2026-07-27 内部类（Inner Class）基础练习（课堂练习用）

第一部分：随堂练习

练习 1：内部类入门——汽车与发动机

练习 2：私有内部类设计——人（Person）与心脏（Heart）

练习 3：静态成员内部类——学校与学生证打印

练习 4：局部内部类——餐厅点餐系统

练习 5：匿名内部类入门——多态接收方式（USB 设备 + 计算器）

5.1 基于接口的匿名内部类（Usb）

5.2 基于抽象类的匿名内部类（Compute）

思考题

练习 6：匿名内部类做方法参数——餐具 + USB 设备（开发中最常用方式）

6.1 Person 吃饭使用餐具

6.2 NoteBook 接入 USB 设备

思考题

练习 7：匿名内部类三种使用方式对比——多功能计算器

预期输出

对比总结填空

第二部分：进阶练习

第 1 题：综合应用——计算机与外设（成员内部类 + 静态内部类）⭐⭐⭐⭐

需求说明

类设计

内部类 1：CPU（成员内部类，非私有）

内部类 2：UsbSpec（静态成员内部类）

内部类 3：Memory（私有成员内部类）

外部类方法

测试类要求

预期输出

思考题

第 2 题：综合应用——银行账户系统（私有内部类 + 局部内部类 + 静态内部类）⭐⭐⭐⭐⭐

需求说明

类设计

测试类要求

思考与设计挑战

预期输出（方案 A 参考）

思考题

第 3 题：综合应用——学生信息管理系统（匿名内部类 + 排序 + 筛选 + 接口回调）⭐⭐⭐⭐⭐

需求说明

类设计

测试类要求

预期输出（参考）

代码补充挑战

思考题

📋 题目总览

20260727-内部类练习.md 40 KB

History Raw