0学习目标 · 评分 · 工具

评分结构（Assessment）

教材与工具

• 教材：Absolute Java，作者 Walter Savitch（第 4 版或更高，非必须购买）。本批内容对应 Ch 1 & 3。
• IntelliJ：从第 2 周起使用的 IDE，Project 必须用 IDE。
• GitHub（学校提供）：用于 Project 版本管理。
• ED Lessons：配套练习材料，自定进度，不计分。

1.1Java 是什么 / 历史

• 由 Sun Microsystems 开发，项目 1991 年启动，团队由 James Gosling 领导。
• 最初目标是为"下一波计算浪潮"——数字消费电子设备（嵌入式系统）——设计一门语言，当时取名 Oak（橡树）。
• 1993 年消费电子方向遇冷，团队转向新的"下一波"——互联网，做了一种嵌入网页浏览器的语言，叫 applet（小应用）。

1.2三大特性

课件列出 Java 的三个关键特性：编译且解释（Compiled and Interpreted）、平台无关且可移植（Platform-Independent & Portable）、面向对象（Object Oriented）。

① 既编译又解释

先看纯编译型语言（以 C 为例）的流程，再对比 Java：

② 平台无关、可移植

③ 面向对象

Java 是面向对象编程（Object Oriented Programming, OOP）语言。常见的程序构件有：类（Classes）、对象（Objects）、方法（Methods） 等——这些会在后续章节深入。

1.3Application vs Applet

Java 程序有两种类型：

1.4Hello World 逐行拆解

// HelloWorld.java: Display "Hello World!" on the screen

import java.lang.*;

public class HelloWorld {
    public static void main(String args[]) {
        System.out.println("Hello World!");
    }
}

注释（Comments）

Java 支持 3 种注释：

• /* */：通常用于多行注释（与 C 相同）
• //：单行注释
• /** */：文档注释（documentation comments），后续会学

import java.lang.*;

• 作用类似 C 的 #include，用来导入额外的类（类似 C 的库）。
• Java 中类被分组到包（package）里。不同人写的包可能有同名的类和方法，靠包名区分（如 ibm.mathlib.* 与 microsoft.mathlib.*）。

public class HelloWorld { }

• 类定义——Java 中所有东西都定义在类里。

public static void main(String args[])

• main 方法的定义，和 C 很像。
• 一个独立 Java 程序必须有一个 main 方法。
• 一个类只能有一个 main() 方法。
• String args[]：定义命令行参数，类似 C。
• public 和 static 关键字后续详解。

System.out.println("Hello World!");

• 作用类似 C 的 printf，但 println 在 Java 里叫方法（method），而 C 的 printf 叫函数（function）。
• System.out：out 是 System 类里的一个对象；System 类定义在 java.lang 包中。

1.5编译运行 + 命令行参数

编译与运行

1. 用文本编辑器写程序，存为 HelloWorld.java。
2. 确认机器装好了 Java 构建与运行环境：javac -version、java -version。
3. 编译：javac HelloWorld.java —— 成功后生成 HelloWorld.class。
4. 运行：java HelloWorld —— 输出 Hello World!。

命令行参数（Command Line Arguments）

运行 java HelloWorld Australia England France 时，main(String args[]) 里的 args[] 会装上这些参数：

args[0] -> Australia
args[1] -> England
args[2] -> France

用 args.length 得到参数个数。课件示例输出：Number of arguments = 3。

1.6Java vs C 的区别

1.7标识符 Identifiers

规则（必须遵守）

• 不能以数字开头。
• 所有字符必须是字母、数字或下划线 _。
• 理论上可以任意长。
• 大小写敏感：Rate、rate、RATE 是三个不同的变量。

约定（惯例，不是强制）

• 变量 / 方法 / 对象：小写字母开头，用大写字母标记"单词"边界（小驼峰），如 topSpeed、bankRate、timeOfArrival。
• 类：大写字母开头（大驼峰），如 PrintDemo、HelloWorld。

1.8数据类型 Data Types

1.9变量 Variables + 类型转换

<type> <variable name> = <initial value>;

int count = 1;
float length = 2.3F;
double height = 6.7;
boolean status = true;

int countX = 1, countY = 2;
countX = countY + countX;
countX += 3;   // 等价于 countX = countX + 3;

类型转换规则（考试高频陷阱）

变量的三种分类

• 实例变量（instance variables）
• 静态 / 类变量（static / class variables）
• 局部变量（local variables）：定义在方法内部的变量

1.10常量 Constants

final int MAX_LENGTH = 420;
final double PI = 3.1428;
final char CHAR_CONSTANT = 'Z';
final boolean BOOL_CONSTANT = true;
final String STRING_CONSTANT = "Welcome to Java";

• 约定用全大写字母命名常量。
• 定义常量时必须显式写出数据类型（这点 C 不要求）。

1.11运算符 Operators

Java 运算符可分为：算术、关系、逻辑、赋值、自增自减、条件、位运算、特殊运算符等。

算术运算符

关系运算符

< <= > >= ==（等于） !=（不等于）。

逻辑运算符 + 真值表

&& 逻辑与、|| 逻辑或、! 逻辑非。

位运算符 Bitwise

& 按位与、| 按位或、^ 按位异或、~ 取反（one's complement）、<< 左移、>> 右移、>>> 无符号右移（补零）。

自增自减 + 条件（三元）运算符

• 自增自减：++ 和 --。
• 条件运算符：exp1 ? exp2 : exp3。例如 x = (a>b) ? a : b; 等价于"若 a>b 则 x=a 否则 x=b"。

数学函数 Math 类

Java 用 Math 类（定义在 java.lang 包）提供 cos、sin、log、sqrt 等函数，用法 Math.方法名()：

double y = Math.sqrt(x);
double z = Math.cos(y);

1.12流程控制 Flow of Control

分支 Branching

四种：if-else、多路 if-else（multi-way）、switch、两路决策表达式（即三元 ?:）。

switch (Controlling_Expression) {
    case Case_Label_1:
        Statement_Sequence_1
        break;
    case Case_Label_2:
        Statement_Sequence_2
        break;
    default:
        Default_Statement_Sequence
        break;
}

循环 Loops

• 循环体（body）：被重复执行的代码；每执行一次叫一次迭代（iteration）；循环可嵌套。
• 三种：while、do-while、for。

for (Initialize_Expressions; Terminate_Expression; Update_Expressions) {
    ...
}

• Initialize：第一次迭代前，初始化/声明控制变量。
• Terminate：每次迭代前求值的 boolean 表达式，决定何时结束。
• Update：每次循环体执行后更新控制变量。

break 与 continue

2.1数组基础：声明 / 初始化 / 默认值

动机：存 1 个整数用 int x;，存 n 个就需要数组 int[] intArray;。

声明（两种写法）

basetype[] varName;   // 写法一（推荐）
basetype   varName[]; // 写法二

int[] intArray;       // 声明了数组，但还没有任何元素

初始化的三种方式

2.2数组是引用（别名陷阱）

int[] intArray_1 = {10, 20, 30, 40};
int[] intArray_2 = intArray_1;        // 不是复制！两个名字指向同一数组
System.out.println(intArray_2[0]);    // 10
intArray_1[0] = 15;                   // 通过 _1 改，_2 也变
System.out.println(intArray_2[0]);    // 15

2.3多维数组

• Java 允许"多维数组"，技术上是"数组的数组"（array of arrays）。
• 声明方式和一维类似。

int[][] nums = new int[10][10];  // 方形数组（square）
int[][] nums = new int[10][];    // 不规则数组（irregular / jagged）

2D 数组初始化略复杂——不规则数组要逐行 new：

for (int i = 0; i < nums.length; i++) {
    nums[i] = new int[<length_of_subarray>];
}

int HEIGHT = 5;
int[][] triangleArray = new int[HEIGHT][];     // 每行长度不同
for (int i = 0; i < HEIGHT; i++) {
    triangleArray[i] = new int[HEIGHT - i];    // 第 i 行有 HEIGHT-i 个元素
    for (int j = 0; j < HEIGHT - i; j++) {
        triangleArray[i][j] = i + j + 1;
    }
}
// 得到 {1,2,3,4,5},{2,3,4,5},{3,4,5},{4,5},{5}

2.4对象数组

数组也能存对象，但要分两步：

Circle[] circleArray;              // ① 声明数组
circleArray = new Circle[25];      // ② 分配存储

Circle[] circleArray = new Circle[3];
for (int i = 0; i < circleArray.length; i++) {
    circleArray[i] = new Circle(i, i, i + 2);   // 逐个创建并存入
}

2.5数组常用方法

2.6For-Each 循环

for (<type> varName : <iterable object>) {
    <block of code>
}

for (Circle c : circleArray) {
    System.out.println(c.getRadius());
}

2.7字符串基础 + 转义

String s1 = "This is a String";
String s2 = "This is " + "also a String";
String s3 = "10";   // 即使内容是数字，它仍是字符串

转义 Escaping

有些字符（如 "）是保留的，对 Java 有特殊含义；要按字面使用它们，需要用 \ 转义。

System.out.println("Game of Thrones season 8 was \"good\".");

2.8字符串拼接陷阱

• 用 + 和 += 拼接字符串。
• + 很"聪明"：只要有一个操作数是字符串，就会把另一个也转成字符串。

System.out.println("1 + 1 = " + 1 + 1);
// 输出 "1 + 1 = 11"  ← 先 "1 + 1 = "+1 拼成字符串, 再 +1 继续拼

System.out.println("1 + 1 = " + (1 + 1));
// 输出 "1 + 1 = 2"   ← 括号让 1+1 先做整数加法

2.9字符串常用方法

2.10不可变性 Immutability

String s = "Hello World";
s.toUpperCase();      // 返回新串, 但被丢弃
s.replace("e", "i");  // 同上
s.substring(0, 2);    // 同上
s += " FIVE";         // 这一行才真的改了 s（替换为新串）
System.out.println(s);
// 输出 "Hello World FIVE"  ← 前三行全部无效

String s = "Hello World";
s = s.toUpperCase();   // "HELLO WORLD"
s = s.replace("e","i");// 此时无 e, 不变
s = s.substring(0, 2); // "HE"
s += " FIVE";
System.out.println(s);
// 输出 "HE FIVE"

2.11== vs .equals + 字符串常量池

这是 Java 最容易出错的点之一。先看课件的几个自测，全部围绕"== 比的到底是什么"。

String s  = "Hello";
String s2 = new String("Hello");
System.out.println(s == s2);        // false（引用不同）
System.out.println(s.equals(s2));   // true （内容相同）

3.1类 vs 对象 + 四大编程概念 + 抽象

• 过程式语言的抽象靠函数 / 过程：函数对外部数据执行操作。
• OO 语言的抽象靠抽象数据类型（ADT, Abstract Data Type）：它把数据 + 操作数据的函数装在一起。
• 在 Java 中，类（Class）就是抽象数据类型的一种实现。

贯穿示例（画图板 Drawing Pad）：以 Circle 类为例——属性有 Centre（中心）、Radius（半径）、Fill Colour/Type；方法有 computeCircumference（算周长）、computeArea（算面积）、move、resize。

3.2OO 六大特性总览

面向对象设计范式的关键特性：数据抽象、封装、信息隐藏、委托、继承、多态。本章覆盖前四个，继承与多态在后续章节。

3.3定义类：属性 + 方法

<visibility modifier> class <ClassName> {
    <attribute declarations>
    <method declarations>
}

public class Circle { }   // 一个"裸"类

加属性（attributes，又叫 data / fields）

public class Circle {
    public double centreX;   // 中心 x 坐标
    public double centreY;   // 中心 y 坐标
    public double radius;    // 半径
}

加方法

<visibility modifier> <void 或 返回类型> myMethod(paramList) {
    变量声明
    语句
}

• 方法有返回值就要在定义里写明返回类型，并且方法体里要有 return 语句；否则写 void。
• 方法内部声明的变量叫局部变量（local variables）——在方法内部，区别于在方法外部声明的实例变量。

public double computeCircumference() {
    return 2 * Math.PI * radius;
}
public double computeArea() {
    return Math.PI * radius * radius;
}
public void resize(double factor) {
    radius = radius * factor;
}

3.4引用 vs 对象 / null / new / 垃圾回收

编译 Circle.java 后，Circle 成为一个派生数据类型（Derived Data Type），区别于 int、float 这种原始数据类型（Primitive）。

Circle aCircle;   // 没有创建对象！
Circle bCircle;

Circle aCircle, bCircle;
aCircle = new Circle();   // aCircle 现在指向一个对象
bCircle = new Circle();   // bCircle 现在指向另一个对象
bCircle = aCircle;        // 赋类引用：两个名字指向同一对象

3.5访问成员（点语法）

<objectName>.<variableName>;
<objectName>.<methodName>(<arguments>);

语法和 C 访问 struct 里的数据类似。

Circle aCircle = new Circle();
aCircle.centreX = 2.0;
aCircle.radius  = 1.0;
double area = aCircle.computeArea();  // 调用方法 = 向对象"发消息"
aCircle.resize(2.0);

3.6Getter / Setter

• 初始化 / 更新 / 访问实例变量，通常用专门的方法来做。
• 这些方法叫访问器 / 修改器（Accessor / Mutator），俗称 Getter / Setter。
• Setter（mutator）：aCircle.setX(10.0); —— 初始化/更新实例变量
• Getter（accessor）：double x = aCircle.getX(); —— 访问实例变量
• IntelliJ、Eclipse 等 IDE 支持自动生成 getter/setter。

public double getRadius() {
    return radius;
}
public void setRadius(double radius) {
    this.radius = radius;   // this 见 3.8
}

3.7构造函数 Constructor

Circle aCircle = new Circle(); 右边其实是在调用类的构造函数。

public <ClassName>(<arguments>) {
    <block of code>
}

public Circle() {              // 无参构造，设默认值
    centreX = 10.0;
    centreY = 10.0;
    radius  = 5.0;
}
public Circle(double newX, double newY, double newR) {  // 带参构造
    centreX = newX;  centreY = newY;  radius = newR;
}

3.8方法重载 Method Overloading + this

构造函数陷阱 → this 关键字

public Circle(double centreX, double centreY, double radius) {
    centreX = centreX;   // ❌ 把参数赋给自己, 实例变量没被改
    centreY = centreY;
    radius  = radius;
}

public Circle(double centreX, double centreY, double radius) {
    this.centreX = centreX;   // this.centreX 是实例变量, centreX 是参数
    this.centreY = centreY;
    this.radius  = radius;
}

3.9static 静态成员 + 实例 vs 静态 ★

问题：怎么统计一共创建了多少个 Circle 对象？答案是用静态变量。

public class Circle {
    public static int numCircles = 0;   // 静态(类)变量, 整个类只有一份
    public double centreX, centreY, radius;

    public Circle(double x, double y, double r) {
        centreX = x; centreY = y; radius = r;
        numCircles++;                    // 每创建一个对象就 +1
    }
    public static void printNumCircles() {       // 静态方法
        System.out.println("Number of circles = " + numCircles);
    }
}

用类名（不是对象名）访问：Circle.numCircles、Circle.printNumCircles();。

3.10标准方法 equals / toString / 拷贝构造

有些常用方法几乎每个类都该有，叫标准方法（Standard Methods）。看三个：

① equals

public boolean equals(<ClassName> var) {
    return <boolean expression>;
}

public boolean equals(Circle circle) {
    return Double.compare(circle.centreX, centreX) == 0 &&
           Double.compare(circle.centreY, centreY) == 0 &&
           Double.compare(circle.radius,  radius)  == 0;
}

② toString

• toString 返回对象的一个 String 表示。
• 当对象被要求"表现得像字符串"时自动被调用，例如 System.out.println(c_1);（c_1 是 Circle 引用）。

public String toString() {
    return "I am a Circle with {centreX=" + centreX +
           ", centreY=" + centreY + ", radius=" + radius + '}';
}
// System.out.println(aCircle);
// 输出: I am a Circle with {centreX=5.0, centreY=5.0, radius=40.0}

③ 拷贝构造函数 Copy Constructor

public <ClassName>(<ClassName> var) {
    <block of code>
}

• 是一个参数为同类型的单参数构造函数。
• 为传入的对象创建一个独立的副本：是一个独立对象，但实例变量被设成和参数对象完全一致。

Circle c1 = new Circle(10.0, 10.0, 5.0);
Circle c2 = c1;             // 引用复制：c2 和 c1 是同一个对象
Circle c3 = new Circle(c1); // 拷贝构造：c3 是新对象, 状态同 c1

3.11包 Packages

为什么分包

• 类似 C 的库：可以开发、打包、被其他 Java 程序导入使用。
• 支持复用：导入现有类，而不是重写。
• 防命名冲突：同名的类可以共存，靠所属包名唯一区分。
• 支持访问控制（见信息隐藏）。
• 是另一层封装。

创建包 / 使用包

// 类文件的第一条语句必须是 package 语句
package utilities.shapes;     // shapes 是 utilities 的子目录
public class Circle { ... }
// Circle.class 必须放在 utilities/shapes 目录下

// 使用包
import utilities.shapes.*;          // 导入包里所有类
import utilities.shapes.Circle;     // 导入特定类

3.12信息隐藏 + 可见性修饰符 ★

三个可见性修饰符

• public：用于类/方法/属性时，处处可见（类内、类外都可见）。
• private：用于方法/属性时，只在该类内可见。private 成员在子类中不可见，也不被继承。
• protected：用于方法/属性时，在该类、子类、以及同包的所有类中可见；其他包里的子类也能看到。

3.13可变 vs 不可变类

public class ImmutableCircle {
    private final double centreX, centreY, radius;  // final + 无 setter
    public ImmutableCircle(double x, double y, double r) { ... }
    public double getCentreX() { ... }   // 只有 getter, 没有 setter
    // ...
}

做法：实例变量设为 private final，且不提供 setter。

3.14关联与委托 Delegation

public class Point {
    private double xCoord, yCoord;
    public double getXCoord() { return xCoord; }
    public double getYCoord() { return yCoord; }
}

public class Circle {
    private Point centre;     // Circle 里包含一个 Point 对象
    private double radius;
    public Circle(Point centre, double radius) {
        this.centre = centre;
        this.radius = radius;
    }
    public double getX() {
        return centre.getXCoord();  // 委托给 centre 这个 Point 对象
    }
    public double getY() {
        return centre.getYCoord();
    }
}

Point 对象被包含在 Circle 对象里；Circle 的方法通过引用 centre 调用 Point 的方法。

3.15包装类 + 装箱拆箱 + parse

parse（解析）

int i     = Integer.parseInt("1");
double d  = Double.parseDouble("1");
boolean b = Boolean.parseBoolean("TruE");
// Integer 类还有: Integer.reverse(10), Integer.signum(-10) 等

4.1为什么需要继承（动机）

象棋里 Pawn、Rook、Knight、Bishop、King、Queen 每个棋子都有 isAlive、isWhite、currentRow、currentColumn 这些属性和 move、isValidMove 方法。如果每个棋子写一个独立类：

4.2继承基础：superclass / subclass / extends / is-a

• 在父类定义公共属性和方法；
• 子类自动拥有父类所有 public/protected 实例变量和方法；
• 子类可以再定义额外的方法和实例变量；
• 继承实现代码复用；子类应是父类的"更具体"版本。

public class Piece {                 // 父类：放共性
    private int currentRow, currentColumn;
    public int getCurrentRow() { return currentRow; }
    public void setCurrentRow(int r) { this.currentRow = r; }
    // ... getCurrentColumn / setCurrentColumn
}

public class Rook extends Piece {    // 子类：只写差异
    public void move(int toRow, int toColumn) { ... }
    public boolean isValidMove(int toRow, int toColumn) { ... }
}
public class Knight extends Piece { ... }

Rook rook1 = new Rook();      // ✅
Piece rook2 = new Rook();     // ✅ Rook "is a" Piece（向上）
Rook rook3 = new Piece();     // ❌ Piece "is not a" Rook（不能向下）

4.3super 调用父类构造函数

子类构造函数不必复制粘贴父类构造代码，用 super 调用父类构造函数。

public class Piece {
    private int currentRow, currentColumn;
    public Piece(int currentRow, int currentColumn) {
        this.currentRow = currentRow;
        this.currentColumn = currentColumn;
    }
}
public class Rook extends Piece {
    public Rook(int currentRow, int currentColumn) {
        super(currentRow, currentColumn);   // 调用父类构造函数
        // 其他代码
    }
}

4.4方法重写 Overriding（vs 重载）

public class Rook extends Piece {
    @Override   // 注解，表明这是在重写父类方法（可选, 但推荐）
    public boolean isValidMove(int toRow, int toColumn) {
        System.out.println("Rook class: isValidMove() method");
        return isValid;
    }
}

4.5super.method() 扩展父类方法

isValidMove 的逻辑有两部分：所有棋子共同的（检查是否在棋盘内）和各自特有的（具体走法）。把通用部分放父类，子类调 super 复用：

public class Piece {
    final static int BOARD_SIZE = 8;
    public boolean isValidMove(int toRow, int toColumn) {
        return toRow >= 0 && toRow < BOARD_SIZE &&
               toColumn >= 0 && toColumn < BOARD_SIZE;   // 通用边界检查
    }
}
public class Rook extends Piece {
    public boolean isValidMove(int toRow, int toColumn) {
        if (!super.isValidMove(toRow, toColumn))   // 先调父类做边界检查
            return false;
        // 再加 Rook 特有的走法逻辑
        return isValid;
    }
}

4.6重写的规则与陷阱

4.7继承中的访问控制 + 隐私泄露

• 子类不能调用父类的 private 方法，不能访问父类 private 属性。
• 子类可以调用父类的 protected 方法，可以访问父类 protected 属性。

4.8遮蔽 Shadowing + 动态绑定 ★

这是本章最容易混的点。先看课件例子：父类 PieceS 和子类 RookS 都声明了 public currentRow（子类变量"遮蔽"了父类的同名变量）。

public class PieceS {
    public int currentRow, currentColumn;
    public PieceS(int currentRow, int currentColumn) {
        this.currentRow = currentRow;   // 设的是 PieceS 的 currentRow
        this.currentColumn = currentColumn;
    }
    public int getCurrentRow() { return this.currentRow; }
}
public class RookS extends PieceS {
    public int currentRow, currentColumn;   // 遮蔽父类的同名变量
    public RookS(int currentRow, int currentColumn) {
        super(currentRow, currentColumn);   // 只设了父类的 currentRow, RookS 自己的还是 0
    }
    public int getCurrentRow() { return this.currentRow; }  // 返回 RookS 的 currentRow
}

RookS  r1 = new RookS(4, 3);
r1.getCurrentRow()  // → 0
r1.currentRow       // → 0

PieceS r2 = new RookS(4, 3);   // 引用类型 PieceS, 对象类型 RookS
r2.getCurrentRow()  // → 0   方法跟【对象类型 RookS】, 返回 RookS.currentRow = 0
r2.currentRow       // → 4   字段跟【引用类型 PieceS】, 访问 PieceS.currentRow = 4

4.9Object 类（toString / equals / hashCode）

• 继承来的 toString 没用：默认打印类似 Rook@1540e19d（类名@哈希），所以要重写它，返回有意义的字符串。
• 继承来的 equals 也没用：默认返回 false（只比引用），所以要重写。

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null) return false;
    if (getClass() != o.getClass()) return false;
    Piece piece = (Piece) o;            // 安全的向下转型
    return currentRow == piece.currentRow &&
           currentColumn == piece.currentColumn;
}
@Override
public int hashCode() {
    return Objects.hash(currentRow, currentColumn);
}

这个版本才真正重写了 Object 的 equals，比第 3 章里那个简化版更标准。比较逻辑可按需替换。

4.10instanceof / 向上向下转型

new Rook()  instanceof Piece   // true
new Piece() instanceof Rook    // false

4.11多态 Polymorphism ★

Shape[] s = new Shape[3];
s[0] = new Circle(0, 0, 1);
s[1] = new Square(0, 0, 2);
for (Shape shape : s) {
    System.out.println(shape.computeArea());  // 各自调自己的 computeArea
}

4.12抽象类与抽象方法 ★

问题：Piece 这个类本身有意义吗？new Piece() 是什么东西？凭空一个"棋子"——它不对应任何真实棋子（兵、车…）。

public abstract class Shape {
    private double centreX, centreY;
    public Shape(double centreX, double centreY) {
        this.centreX = centreX;  this.centreY = centreY;
    }
    public abstract double computeArea();   // 抽象方法, 无方法体, 以分号结尾
}
public class Circle extends Shape {
    private double radius;
    public Circle(double x, double y, double radius) {
        super(x, y);  this.radius = radius;
    }
    @Override
    public double computeArea() { return Math.PI * Math.pow(radius, 2); }
}

4.13继承的类型 + Java 不支持多继承

继承可以有多级，例如 Shape → Circle → GraphicCircle。更一般地，继承有几种形式：

• 单继承 Single：只有一个父类
• 多继承 Multiple：多个父类
• 层次继承 Hierarchical：一个父类，多个子类
• 多级继承 Multi-Level：从一个派生类再派生
• 混合继承 Hybrid：多于两种类型的组合
• 多路继承 Multi-path：从两个来源继承某些属性

5.1Git 版本控制（模型 + 命令）

5.2Maven 构建管理

5.3IntelliJ 调试器

调试 Debugging：查找并修复软件中的 bug。调试器让你逐步走查程序、在运行时检查程序状态——比"乱改试试"或"printf 调试"高效得多。

5.4Bagel 游戏框架

import bagel.*;
public class BagelTest extends AbstractGame {
    private Image smiley;
    private float x = 100, y = 100;

    public BagelTest() {
        super(800, 600, "Bagel Demo");      // 窗口宽, 高, 标题
        smiley = new Image("res/smiley.png");
    }
    public static void main(String[] args) {
        BagelTest game = new BagelTest();
        game.run();                          // 启动游戏
    }
    @Override
    public void update(Input input) {        // 游戏主循环, 约 60 次/秒
        float speed = 0.5f;
        if (input.isDown(Keys.LEFT))  { x -= speed; }
        if (input.isDown(Keys.RIGHT)) { x += speed; }
        if (input.wasPressed(Keys.ESCAPE)) { Window.close(); }
        smiley.draw(x, y);
    }
}

5.5开源项目

课件观点：为开源项目做贡献是展示就业能力的最佳方式之一——因为它要求高质量代码、理解复杂应用、学习陌生技能、在分布式团队协作、遵守项目规范。核心 take-away：学会用 Git、熟悉若干工具、善用调试器、会用 Bagel、学会 Google。

6.1命令行参数

java MyProg Hello World 10
// args = {"Hello", "World", "10"}   ← 三个元素

java MyProg "Hello World" 10
// args = {"Hello World", "10"}      ← 多词字符串用引号, 算一个元素

int age = Integer.parseInt(args[0]);
double height = Double.parseDouble(args[1]);
String name = args[2];

6.2Scanner 键盘输入

Java 提供比 C/Python 更强大的输入方式：Scanner。

import java.util.Scanner;                       // ① 先导入
Scanner scanner = new Scanner(System.in);      // ② 创建

6.3Scanner 两大陷阱 ★

double d = scanner.nextDouble();
float  f = scanner.nextFloat();
int    i = scanner.nextInt();
// 输入 "5 6.7 7.2" → Error！因为 nextInt 读到 7.2 不是整数

double d  = scanner.nextDouble();   // 读 5
String s1 = scanner.nextLine();     // 读到 5 后面剩下的空（换行前的空白）→ ""
String s2 = scanner.nextLine();     // 读下一行 → "6.7"
// 输入:
//   5
//   6.7
//   7.2
// 输出: 5.00 , (空) , 6.7

double rating = scanner.nextDouble();
scanner.nextLine();                 // 吃掉残留换行
String comment = scanner.nextLine();// 现在能正确读到下一行

6.4读文件

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;

try (BufferedReader br =
         new BufferedReader(new FileReader("test.txt"))) {
    String text;
    while ((text = br.readLine()) != null) {   // 逐行读, 读到 null 为止
        System.out.println(text);
    }
} catch (Exception e) {
    e.printStackTrace();
}

try (Scanner file = new Scanner(new FileReader("test.txt"))) {
    while (file.hasNextLine()) {
        System.out.println(file.nextLine());
    }
} catch (Exception e) { e.printStackTrace(); }

6.5CSV 文件

// recipe.csv:
// Ingredient,Cost,Quantity
// Bananas,9.2,4
// Eggs,1,6

while ((text = br.readLine()) != null) {
    String cells[] = text.split(",");          // 按逗号拆成各列
    String ingredient = cells[0];
    double cost = Double.parseDouble(cells[1]);
    int quantity = Integer.parseInt(cells[2]);
}

6.6写文件

import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;

try (PrintWriter pw =
         new PrintWriter(new FileWriter("testOut.txt"))) {
    pw.println("Hello World");
    pw.format("Device is %s, price $%d", "iPhone", 100000);
} catch (IOException e) {
    e.printStackTrace();
}

6.7读写结合 + append 模式

try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
     PrintWriter pw = new PrintWriter(new FileWriter("output.txt"))) {
    String text;
    while ((text = br.readLine()) != null) {
        pw.println(text.toLowerCase());   // 边读边写
    }
} catch (Exception e) { e.printStackTrace(); }

两个典型应用：① 用文件在计算过程中存储/恢复中间数据；② 用 Java 解析/操作/转换文件（读入→处理→写出）。

6.8考试要求

7.1接口是什么

7.2定义接口的隐含规则 ★

public interface Printable {
    int MAXIMUM_PIXEL_DENSITY = 1000;   // 一个常量
    void print();                        // 一个抽象方法
}

7.3实现接口 implements

public class Image implements Printable {
    public void print() {
        // 具体怎么打印图片
    }
}
public class Spreadsheet implements Printable {
    public void print() {
        // 具体怎么打印表格
    }
}

7.4default 方法

public interface Printable {
    default void print() {
        System.out.println(this.toString());
    }
}

7.5一个类可以实现多个接口 ★

public class Spreadsheet extends Document
        implements Printable, Colourable, Filterable, Comparable<Spreadsheet> {
    public void print() {
        // ...
    }
    // 还要实现 Colourable / Filterable / compareTo 里的方法
}

7.6接口 vs 抽象类 ★

这是接口这一讲最高频的辨析考点。两者都"不能实例化、都用来做抽象"，但定位不同。先回顾抽象类：

7.7Comparable 接口

public class RandomNumber implements Comparable<RandomNumber> {
    public final int number;
    public RandomNumber() {
        this.number = new Random().nextInt(100);
    }
    public int compareTo(RandomNumber other) {
        return this.number - other.number;   // 差值天然满足"负/零/正"约定
    }
    public String toString() {
        return Integer.toString(this.number);
    }
}

8.1泛型是什么 + 类型参数 T

public interface Comparable<T> {
    public int compareTo(T other);
}

8.2Comparable<T>：泛型 vs 非泛型

对比两种写法，体会泛型的好处。非泛型版用 Object + instanceof + 强制转型：

public class Circle implements Comparable {     // 非泛型
    @Override
    public int compareTo(Object o) {
        if (o instanceof Circle) {
            Circle c = (Circle) o;              // 必须手动转型
            // ... 比较 radius, 返回 1 / -1 / 0
        } else {
            return -2;                          // 类型不对只能返回一个"无效"值
        }
    }
}
// c1.compareTo(s) 拿 Circle 比 Square → 返回 -2, 程序员还得处理 -2

public class CircleT implements Comparable<CircleT> {  // 泛型
    @Override
    public int compareTo(CircleT c) {           // 参数直接是 CircleT, 不用转型
        // ... 比较 radius
    }
}
// c1.compareTo(s)  ← Circle 比 Square, 直接编译错误！

8.3ArrayList 入门

ArrayList 是一个常用的泛型类，弥补了数组的局限（定长、手动 resize、增删费力）。

import java.util.ArrayList;
ArrayList<Circle> circles = new ArrayList<Circle>();
circles.add(new Circle(0.0, 0.0, 5));
for (Circle c : circles) { ... }    // 可像数组一样 for-each

8.4定义泛型类（单 / 多类型）

public class Sample<T> {           // 单类型参数
    private T data;
    public void setData(T data) { this.data = data; }
    public T getData() { return data; }
}

public class TwoTypePair<T1, T2> { // 多类型参数
    private T1 first;
    private T2 second;
    public void setFirst(T1 first) { this.first = first; }
    public void setSecond(T2 second) { this.second = second; }
}
// 使用:
TwoTypePair<String, Integer> rating =
    new TwoTypePair<String, Integer>("The Car Guys", 8);

8.5有界类型参数 Bounded Type Parameters

有时需要保证类型参数具备某种行为，就给它加上界（bound），用 extends：

public class Generic<T extends Comparable<T>> { }   // T 必须可比较
public class Generic<T extends Robot> { }            // T 必须是 Robot 或其子类
public class Generic<T extends Robot
                     & Comparable<T> & List<T>> { }  // 多重界限, 用 & 连接

8.6泛型方法 Generic Method

public <T> int genericMethod(T arg);          // 泛型参数
public <T> T   genericMethod(String name);    // 泛型返回值
public <T> T   genericMethod(T arg);          // 两者都有
public <T,S> T genericMethod(S arg);          // 两个类型参数

// 例: 统计 item 在 array 中出现次数
public static <T> int countOccurrences(T[] array, T item) {
    int count = 0;
    for (T arrayItem : array) {
        count = item.equals(arrayItem) ? count + 1 : count;
    }
    return count;
}

8.7泛型的限制

9.1Collections vs Maps 框架概览

9.2选哪种集合

9.3Collection 常用操作

9.4ArrayList 进阶 + Iterator

ArrayList 可存"同一基类"的不同子类对象，实现多态：

ArrayList<Shape> shapes = new ArrayList<Shape>();
shapes.add(new Circle(0.0, 0.0, 5));   // Circle extends Shape
shapes.add(new Square(0.0, 0.0, 7));   // Square extends Shape
for (Shape s : shapes) {
    System.out.println(s.getArea());   // 各自调自己的 getArea(), 无缝多态
}

Iterator<Circle> it = circles.iterator();
while (it.hasNext()) {        // hasNext(): 还有下一个吗
    Circle c = it.next();     // next(): 返回下一个
    System.out.println(c.getRadius());
}

9.5泛型不变性 Invariance ★

ArrayList<Shape> shapes = new ArrayList<>();
shapes.add(new Circle(...));   // OK
shapes.add(new Square(...));   // OK

ArrayList<Shape> list1 = new ArrayList<Circle>();  // ❌ 不合法
ArrayList<Shape> list2 = new ArrayList<Square>();  // ❌ 不合法

Shape[] shapes1 = new Shape[10];
Shape[] shapes2 = new Square[10];   // ✅ 数组允许这样（协变 covariant）

9.6排序：Comparable<T>

public class Movie implements Comparable<Movie> {
    private int year;
    public int compareTo(Movie m) {
        return this.year - m.year;   // 按年份升序
    }
}
// 排序: Collections.sort(list);  ← 用类的默认顺序(compareTo)
//      list 会被直接修改

9.7排序：Comparator<T> + Collections.sort

public class RatingComparator implements Comparator<Movie> {
    public int compare(Movie m1, Movie m2) {
        if (m1.getRating() < m2.getRating()) return -1;
        if (m1.getRating() > m2.getRating()) return 1;
        return 0;
    }
}

9.8匿名内部类 Anonymous Inner Class

给每种排序都建一个 Comparator 类有点小题大做。匿名内部类是更轻的方案。

Collections.sort(list, new Comparator<Movie>() {
    @Override
    public int compare(Movie m1, Movie m2) {
        if (m1.getRating() < m2.getRating()) return -1;
        if (m1.getRating() > m2.getRating()) return 1;
        return 0;
    }
});   // 直接在这里定义并实例化, 不用单独写一个 RatingComparator 文件

9.9Maps：HashMap / TreeMap

HashMap<String, Book> library = new HashMap<>();
library.put(b1.getAuthor(), b1);

// 遍历方式一: 按 keySet
for (String author : library.keySet()) {
    Book b = library.get(author);
}
// 遍历方式二: 按 entrySet（拿到键和值）
for (Map.Entry<String, Book> entry : library.entrySet()) {
    String author = entry.getKey();
    Book b = entry.getValue();
}

9.10泛型在框架中的价值 + 实战提示

10.1设计流程：识别类与关系

10.2UML 是什么

10.3UML 表示一个类

一个类用三栏框表示：类名 / 属性 / 方法。

10.4四种类关系总览 ★

10.5关联 Association

10.6多重性 Multiplicity

10.7聚合 vs 组合 ★

聚合和组合都是关联的子集，区别在"部分"能否脱离"整体"独立存在。

10.8泛化 / 实现 / 依赖

10.9UML 工具

课件推荐：draw.io（SWEN30006 首选）、LucidChart（学生邮箱注册解锁完整功能）、StarUML、带插件的 IDE（可把 UML 转代码）等。

11.1三类错误

11.2处理运行时错误的三种方案

11.3try / catch / finally

try {
    // 可能抛异常的代码
} catch (ExceptionClass e) {
    // 从异常中恢复, 或结束程序
} finally {
    // 无论是否发生异常都会执行
}

11.4为什么需要 finally

11.5多 catch 块

try {
    ...
} catch (FileNotFoundException e) {   // 最具体的(子类)在前
    e.printStackTrace();
} catch (IOException e) {             // 更宽泛的(父类)在后
    e.printStackTrace();
}

11.6throw vs throws

public Person(int age, String name) {
    if (name == null) {
        throw new NullPointerException("Creating person with null name");
    }
    this.age = age; this.name = name;
}

11.7自定义异常

// 第1步: 写异常类
public class InvalidRadiusException extends Exception {
    public InvalidRadiusException() {
        super("Radius is not valid");
    }
    public InvalidRadiusException(double radius) {
        super("Radius [" + radius + "] is not valid");
    }
}
// 第2步: 在可能出错处 throw, 并在方法签名 throws
public Circle(double cx, double cy, double radius)
        throws InvalidRadiusException {
    if (radius <= 0) throw new InvalidRadiusException(radius);
    ...
}
// 第3步: 调用处 try-catch, 用 e.getMessage() 取消息

11.8Checked vs Unchecked ★

11.9Catch-or-Declare + try-with-resources

try (BufferedReader reader = ...) {
    ...
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

12.1这一章在讲什么

12.2编码规范 Coding Standards

12.3注释 Comments + 放置位置 ★

// 不好：注释写在代码下面
<一行代码>
// This is a comment below my code

// 好：注释写在代码上面
// This is a comment above my code
<一行代码>

12.4JavaDoc 文档注释

/** 这个例子演示如何用各种标签写 javadoc 注释
 * @author Andrew Valentine
 * @version 1.0
 */
public class JavaDocExample {
    /** 把两个整数相加
     * @param a addNum 的第一个参数
     * @param b addNum 的第二个参数
     * @return int 返回 a 与 b 的和
     */
    public int addNum(int a, int b) {
        return a + b;
    }

    /** 主方法, 调用 addNum
     */
    public static void main(String[] args) {
        JavaDocExample jd = new JavaDocExample();
        System.out.println("Sum of numbers is: " + jd.addNum(1, 2));
    }
}

12.5设计原则总览

12.6五个易混概念对照表 ★

这几个词长得像、经常一起出现，但各自回答不同的问题。这张表是本章最容易考"概念辨析"的地方，建议直接背下来。

12.7模块化 Modularity

public class Player { ... }
public class Enemy  { ... }
public class Level  { ... }
public class Game   { ... }

12.8内聚 Cohesion ★

public class Player {
    private int health;
    public void move()        { ... }   // 玩家行为 ✓
    public void attack()      { ... }   // 玩家行为 ✓
    public void drawOnScreen(){ ... }   // 画图 —— 不该归玩家管
    public void saveToFile()  { ... }   // 存档 —— 也不该归玩家管
}

public class Player {
    private int health;
    public void move()   { ... }
    public void attack() { ... }
}
public class GameRenderer {
    public void drawPlayer(Player player) { ... }
}
public class SaveManager {
    public void savePlayer(Player player) { ... }
}

12.9耦合 Coupling ★

public class Game {
    private KeyboardController controller = new KeyboardController();
}

public class Game {
    private Controller controller;
    public Game(Controller controller) {   // 从外面传进来
        this.controller = controller;
    }
}

12.10抽象 / 封装 / 多态 / 委托

public class Player {
    private int health;
    private int x, y;
    public void move(int dx, int dy)   { ... }
    public void takeDamage(int amount) { ... }
}

ArrayList<Enemy> enemies = new ArrayList<>();
enemies.add(new Bug());
enemies.add(new Robot());
for (Enemy enemy : enemies) {
    enemy.update();   // 各自表现各自的行为
}

12.11开闭原则 Open-Closed ★

public void makeDogSound(String dogType) {
    if (dogType.equals("Poodle")) {
        System.out.println("yap");
    } else if (dogType.equals("Bulldog")) {
        System.out.println("woof");
    }
}   // 每加一种狗, 就得回来改这串 if-else

public interface Dog {
    void makeSound();
}
public class Poodle implements Dog {
    public void makeSound() { System.out.println("yap"); }
}
public class Bulldog implements Dog {
    public void makeSound() { System.out.println("woof"); }
}

ArrayList<Dog> dogs = new ArrayList<>();
dogs.add(new Poodle());
dogs.add(new Bulldog());
for (Dog dog : dogs) {
    dog.makeSound();
}

public class Husky implements Dog {
    public void makeSound() { System.out.println("awoo"); }
}

13.1设计模式是什么 + 怎样成为好设计师

13.2模式规格说明：怎么读懂一个模式 ★

课程明确要求你能"分析并理解设计模式的规格说明（specification）"。每个模式发布时通常用下面这套固定栏目来描述。考试可能给你一个模式让你按这些栏目分析，建议记住每栏在回答什么。

13.3三大类模式总览

模式按"解决哪一类问题"分成三大类。先有这张地图，下面五个模式各属于哪类就清楚了。

13.4单例 Singleton ★

public class Singleton {
    private static Singleton instance = null;   // 唯一实例, 静态
    private String name;

    private Singleton() {        // 构造函数私有! 外部无法 new
        name = "George";
    }

    // 保证全程只有 1 个实例
    public static Singleton getInstance() {
        if (instance == null) {              // 第一次调用才创建
            instance = new Singleton();
        }
        return instance;                     // 之后都返回同一个
    }

    public String getName() { return name; }
}

x = Singleton.getInstance();
y = Singleton.getInstance();
System.out.println(x == y);   // true —— x 和 y 指向同一个对象

13.5工厂方法 Factory Method

// 不这样:
players.add(new RPGPlayer());
// 而是这样:
players.add(createPlayer());   // 由子类决定 createPlayer() 造哪种 Player

abstract class Game {
    public abstract Player createPlayer();   // 工厂方法
    public void operation() {
        Player p = createPlayer();            // 用产品, 但不关心是哪种
        ...
    }
}
class RPGGame extends Game {
    public Player createPlayer() { return new RPGPlayer(); }
}
class ShooterGame extends Game {
    public Player createPlayer() { return new ShooterPlayer(); }
}

13.6模板方法 Template Method

public abstract class PriceCalculator {
    public double finalPrice(double price) {   // 算法骨架(不变)
        double discounted = applyDiscount(price);
        return addGST(discounted);
    }
    public abstract double applyDiscount(double price);  // 留给子类(变)
    public double addGST(double price) {        // 共享步骤(不变)
        return price * 1.10;
    }
}

13.7策略 Strategy

public interface DiscountStrategy {
    double applyDiscount(double price);
}
// 不同折扣 = 不同实现类, 都实现这个接口
// Context 持有一个 DiscountStrategy, 需要打折时就调它

13.8模板方法 vs 策略：继承 vs 组合 ★

这两个是行为型模式里最容易混的一对，因为它们解决的是同一类问题（让"会变的行为"可替换、可复用），只是用了两种不同机制。这是高频考点，务必分清。

13.9观察者 Observer ★

public class Player extends Observable {       // Subject
    public Player(String name, ArrayList<Observer> observers) {
        for (Observer o : observers) addObserver(o);  // 登记观察者
        setChanged();                                  // 标记"我变了"
        notifyObservers("Player created: " + name);    // 广播通知
    }
}
public abstract class Enemy implements Observer {   // Observer
    public abstract void update(Observable o, Object arg);
}

// Observer 接口: 谁想在分数变化时被通知, 就实现它
public interface ScoreObserver {
    void onScoreChanged(int newScore);
}
// Subject: 持有分数, 一旦变化就通知所有登记的观察者
public class ScoreManager {
    private int score = 0;
    private final ArrayList<ScoreObserver> observers = new ArrayList<>();

    public void addObserver(ScoreObserver o) { observers.add(o); }

    public void add(int points) {
        score += points;
        if (score < 0) score = 0;
        notifyObservers();                 // 状态变了 → 广播
    }
    private void notifyObservers() {
        for (ScoreObserver o : observers) o.onScoreChanged(score);
    }
}

14.1三个关键词：Unit / Unit Test / Unit Testing

14.2测试用例：有效 / 无效 / 边界输入 ★

14.3手动测试 vs 自动测试

14.4JUnit5 入门：导入 + @Test + 命名 ★

import org.junit.jupiter.api.Test;              // 提供 @Test 注解
import static org.junit.jupiter.api.Assertions.*;  // 提供 assertXxx 方法 (静态导入)

14.5断言方法 Assertion Methods ★

JUnit5 提供很多断言方法，还有接收不同参数类型/数量的变体。下面这几个是必须记住的核心：

14.6完整示例：BoardTest

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class BoardTest {
    @Test
    public void testBoard() {
        Board board = new Board();
        Move move = new Move(0, 0);
        assertEquals(true, board.cellIsEmpty(move));   // 新棋盘格子应为空
    }

    @Test
    public void testValidMove() {
        Board board = new Board();
        Move move = new Move(0, 0);
        assertEquals(true, board.isValidMove(move));   // (0,0) 是合法落子
    }

    @Test
    public void testMakeMove() {
        Board board = new Board();
        Player player = new HumanPlayer("R");
        Move move = new Move(0, 0);
        board.makeMove(player, move);
        assertEquals("R", board.getBoard()[move.row][move.col]);
    }
}

14.7测试自己也会有 bug + 边界用例 ★

assertEquals("r", board.getBoard()[move.row][move.col]);  // bug! 应是 "R"

@Test
public void testValidMove2() {
    Board board = new Board();
    Move move = new Move(-1, 0);        // 行 = -1, 越出上边界
    assertEquals(false, board.isValidMove(move));
}

15.1什么是事件驱动编程

15.2三个关键词：State / Event / Callback ★

15.3事件的流动 + 控制反转 ★

15.4为什么用它（优点）

15.5例子：JavaFX 按钮

import javafx.event.ActionEvent;
import javafx.event.EventHandler;

public class StopButtonHandler implements EventHandler<ActionEvent> {
    @Override
    public void handle(ActionEvent actionEvent) {
        System.out.println("I am the stop button.");
    }
}

public class DisplayButton extends Application {
    private Button stopButton;
    @Override
    public void start(Stage primaryStage) throws Exception {
        primaryStage.setTitle("Button Demo");

        stopButton = new Button();
        stopButton.setText("Stop");
        StackPane stackPane = new StackPane();
        stackPane.getChildren().add(stopButton);

        stopButton.setOnAction(new StopButtonHandler());  // ★ 注册监听器

        primaryStage.setScene(new Scene(stackPane, 300, 275));
        primaryStage.show();
        System.out.println("Displaying window");
    }
    public static void main(String[] args) { launch(args); }
}

15.6对照你的项目：Bagel 的 update 轮询

@Override
public void update(Input input) {
    if (input.isDown(Keys.DOWN)) {        // 持续按住
        y += speed;
    }
    if (input.wasPressed(Keys.ESCAPE)) {  // 这一帧刚按下
        Window.close();
    }
}

15.7它和异常处理 / 观察者的联系

16.1枚举 enum ★

public enum Rank {
    ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN,
    EIGHT, NINE, TEN, JACK, QUEEN, KING
}

Rank rank = Rank.ACE;
Card card = new Card(Rank.FOUR, ...);

public boolean isFaceCard() {
    return this.ordinal() > Rank.TEN.ordinal();  // 比 TEN 靠后的是花牌
}

ranks = [TEN, FOUR, EIGHT, THREE, ACE];
Collections.sort(ranks);
// → [ACE, THREE, FOUR, EIGHT, TEN]   按声明顺序 ACE..KING 排

16.2可变参数 Variadic Parameters

public int sum(int... numbers) {   // numbers 实际是 int[]
    int total = 0;
    for (int n : numbers) total += n;
    return total;
}
sum(1, 2);          // 传几个都行
sum(1, 2, 3, 4, 5); // 不用为每种个数写一个重载

16.3函数式接口 Functional Interface ★

@FunctionalInterface
public interface Attackable {
    void attack();          // 唯一的抽象方法
}

16.4Lambda 表达式 ★

(参数1, 参数2, ...) -> (对这些参数做的操作)

Predicate<Integer> p = (i) -> (i > 0);

16.5方法引用 Method References

// 这两行完全等价:
UnaryOperator<String> op = s -> s.toLowerCase();   // lambda
UnaryOperator<String> op = String::toLowerCase;    // 方法引用(更简洁)

names.replaceAll(String::toUpperCase);  // 把列表里每个字符串转大写

16.6流 Streams ★

List<Person> people = Arrays.asList(
    new Person("Peter Parker", 18),
    new Person("Black Widow", 34),
    new Person("Thor", 1500),
    new Person("Nick Fury", 67),
    new Person("Iron Man", 49)
);
String output = people.stream()
    .filter(p -> p.getAge() >= 18)     // 留下 ≥18 岁
    .filter(p -> p.getAge() <= 40)     // 再留下 ≤40 岁
    .map(Person::getName)              // 取出名字(方法引用)
    .map(String::toUpperCase)          // 名字转大写(方法引用)
    .collect(Collectors.joining(", ")); // 用 ", " 拼成一个 String
System.out.println(output);
// 输出: PETER PARKER, BLACK WIDOW