Java 面向对象编程

运行一个完整示例 · 01

观察转换发生的时点

比较整数除法、浮点除法与乘法前扩宽。

public class Main {

    public static void main(String[] args) {
        int trips = 7, days = 2;
        double late = trips / days;
        double early = (double)trips / days;
        int width = 50000;
        long area = (long)width * width;
        System.out.println("late=" + late);
        System.out.println("early=" + early);
        System.out.println("area=" + area);
        System.out.println("truncate=" + (int)-3.9);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

late=3.0
early=3.5
area=2500000000
truncate=-3

按执行顺序理解

1. trips 和 days 都声明为 int，因此第一次除法采用整数运算。

2. 在除法前转换 trips，在乘法前转换 width，以改变运算类型。

3. 打印带名称的结果，显示信息在哪里丢失。

逐步读懂代码

操作数在赋值之前决定除法类型。7/2 已变为 3，所以 late 接收 3.0。early 先转换 trips，因此保留小数。

乘法前的转换让结果使用 long。最后的转换向零截断，得到 −3，而非 −4。这些是语言规则，不是对处理器存储的猜测。

运行一个完整示例 · 02

分开解析与有效范围

处理固定文本，不需要交互输入。

public class Main {

    public static void main(String[] args) {
        for (String text : new String[] {"12", "-2", "twelve", "2147483648"}) {
            try {
                int value = Integer.parseInt(text);
                if (value < 0)
                    System.out.println(text + ": negative count");
                else
                    System.out.println(text + ": accepted " + value);
            } catch (NumberFormatException ex) {
                System.out.println(text + ": invalid int text");
            }
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

12: accepted 12
-2: negative count
twelve: invalid int text
2147483648: invalid int text

按执行顺序理解

1. 数组按固定顺序提供四种不同输入。

2. parseInt 先检查十进制 int 表示，再执行符号规则。

3. catch 报告转换失败，并让下一次迭代继续。

逐步读懂代码

每段文本在自己的 try 块内解析。格式合法的负整数进入领域检查。非数值文本与超过 int 范围的整数都会解析失败。

处理器位于循环内部，所以单项失败后继续处理。没有把无效值悄悄改为零。

运行一个完整示例 · 01

追踪已处理前缀

每次更新后打印不变式状态。

public class Main {

    public static void main(String[] args) {
        int[] values = {4, 0, 7};
        int total = 0;
        for (int i = 0; i < values.length; i++) {
            total += values[i];
            System.out.println("processed=" + (i + 1) + ", total=" + total);
        }
        int emptyTotal = 0;
        for (int value : new int[0])
            emptyTotal += value;
        System.out.println("empty total=" + emptyTotal);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

processed=1, total=4
processed=2, total=4
processed=3, total=11
empty total=0

按执行顺序理解

1. 初始化 total，建立空前缀不变式。

2. 使用 i<length，让每次索引读取都在边界内。

3. 相加后打印，再在空输入上运行同样的累加思路。

逐步读懂代码

第 i 次迭代前，total 恰含前 i 项。加 values[i] 后，前缀扩展一项。打印发生在加法后，所以已处理数量为 i+1。

空数组的增强 for 不执行循环体，总和保持零。这个对照检查边界，而无需特判返回。

运行一个完整示例 · 02

保护空引用并在首个匹配处停止

组合短路保护与有界搜索。

public class Main {

    public static void main(String[] args) {
        String[] names = {null, "", "oak", "pine", "elm"};
        int found = -1;
        for (int i = 0; i < names.length; i++) {
            String name = names[i];
            if (name == null || name.isEmpty())
                continue;
            if (name.length() == 4) {
                found = i;
                break;
            }
        }
        System.out.println("first length-four index=" + found);
        System.out.println("matched=" + names[found]);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

first length-four index=3
matched=pine

按执行顺序理解

1. 使用 −1 作为明确的未找到标记。

2. 先用 continue 跳过无效项，再调用其他 String 方法。

3. 保存首个匹配索引，并用 break 退出循环。

逐步读懂代码

保护条件跳过缺失或空名称。name 为 null 时，|| 不调用 isEmpty。留下的名称可安全检查。

首个四字母名称 pine 在索引三。break 保持“首个匹配”的含义。本例已知存在匹配，一般调用者必须先检查 found 再索引。

运行一个完整示例 · 01

比较修改与重新赋值

调用后观察调用者原数组。

import java.util.Arrays;

public class Main {
    static void change(int[] x) {
        x[0] = 10;
        System.out.println("after mutation=" + Arrays.toString(x));
        x = new int[] {1, 2};
        System.out.println("local replacement=" + Arrays.toString(x));
    }
    public static void main(String[] args) {
        int[] scores = {6, 8};
        change(scores);
        System.out.println("caller=" + Arrays.toString(scores));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

after mutation=[10, 8]
local replacement=[1, 2]
caller=[10, 8]

按执行顺序理解

1. 把 scores 的引用值复制到新形参 x。

2. 先修改共享元素，再重新绑定形参。

3. 返回后检查 scores，判断哪种改动对调用者可见。

逐步读懂代码

两个引用起初到达同一数组。元素赋值改变该数组，重设 x 只改变被调用方的路径。

调用者仍看到 [10,8]。方法内与返回后分别打印，能展示两种状态，而不把引用误当成可见数值地址。

运行一个完整示例 · 02

明确返回替代引用

比较复制包装值与接收返回数组。

import java.util.Arrays;

public class Main {
    static void increment(Integer x) {
        x++;
        System.out.println("local count=" + x);
    }
    static int[] doubled(int[] input) {
        int[] result = input.clone();
        for (int i = 0; i < result.length; i++)
            result[i] *= 2;
        return result;
    }
    public static void main(String[] args) {
        Integer count = 4;
        increment(count);
        System.out.println("caller count=" + count);
        int[] values = {2, 5};
        int[] replacement = doubled(values);
        System.out.println("original=" + Arrays.toString(values));
        values = replacement;
        System.out.println("adopted=" + Arrays.toString(values));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

local count=5
caller count=4
original=[2, 5]
adopted=[4, 10]

按执行顺序理解

1. 分别观察局部包装值替换与调用者 count。

2. 先克隆再加倍，使输入不被修改。

3. 由调用者明确接收返回引用。

逐步读懂代码

递增包装对象只重新赋值局部形参。doubled 创建独立基本类型数组，并修改副本。

原数组保持 [2,5]，直到调用者选择用返回引用替换自己的变量。其他指向旧数组的别名仍会到达旧数组。

运行一个完整示例 · 01

追踪浅复制与逐行复制

观察哪些修改越过各复制边界。

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        int[][] original = {{2, 5}, {9}};
        int[][] shallow = original.clone();
        shallow[0][1] = 7;
        shallow[1] = new int[] {4, 6, 8};
        System.out.println("original=" + Arrays.deepToString(original));
        System.out.println("shallow=" + Arrays.deepToString(shallow));
        int[][] isolated = new int[original.length][];
        for (int i = 0; i < original.length; i++)
            isolated[i] = original[i].clone();
        isolated[0][0] = 99;
        System.out.println("original after isolated edit=" +
                           Arrays.deepToString(original));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

original=[[2, 7], [9]]
shallow=[[2, 7], [4, 6, 8]]
original after isolated edit=[[2, 7], [9]]

按执行顺序理解

1. 克隆外层数组并修改共享行。

2. 替换一个行引用，区分槽位修改与单元修改。

3. 独立修改之前先逐行克隆。

逐步读懂代码

外层克隆共享两个原始行。修改单元会通过 original 可见。替换 shallow[1] 则只改变该外层槽位。

第二种复制克隆每个基本类型行，因此之后修改其单元不会改变 original。本例没有 null 行，一般复制器需要检查。

运行一个完整示例 · 02

处理 null 行与受检查的存储

展示两种数组边界，并明确处理失败。

public class Main {

    public static void main(String[] args) {
        int[][] rows = {{1, 2}, null, {}, {3}};
        int cells = 0;
        for (int[] row : rows)
            if (row != null)
                cells += row.length;
        System.out.println("cells=" + cells);
        Object[] values = new String[2];
        values[0] = "safe";
        try {
            values[1] = Integer.valueOf(5);
        } catch (ArrayStoreException ex) {
            System.out.println("incompatible store rejected");
        }
        System.out.println("second slot=" + values[1]);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

cells=3
incompatible store rejected
second slot=null

按执行顺序理解

1. 读取 length 前先检查 row!=null。

2. 将 String 数组赋给较宽引用类型，但实际元素类型保留。

3. 捕获刻意触发的存储失败，并检查状态未变。

逐步读懂代码

计数使用各已存在行自己的长度。null 行没有数组，所以不贡献单元数。

Object[] 变量引用实际 String 数组。写入 Integer 在改变槽位前抛异常，因此该槽位仍为 null。这也说明泛型集合为何选择不变的类型规则。

运行一个完整示例 · 01

区分文本值与对象身份

使用不同对象，避免字符串常量驻留掩盖错误比较。

public class Main {

    public static void main(String[] args) {
        String a = new String("harbor");
        String b = new String("harbor");
        System.out.println("identity=" + (a == b));
        System.out.println("content=" + a.equals(b));
        a.toUpperCase(java.util.Locale.ROOT);
        System.out.println("ignored result=" + a);
        a = a.toUpperCase(java.util.Locale.ROOT);
        System.out.println("assigned result=" + a);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

identity=false
content=true
ignored result=harbor
assigned result=HARBOR

按执行顺序理解

1. 在不同对象中创建相同文本，打印两种比较结果。

2. 调用变换但不接收结果。

3. 接收返回的 String，再观察变量改变。

逐步读懂代码

new 保证本例使用不同 String 对象，equals 检查内容。Locale.ROOT 使大小写转换不依赖机器默认地区。

第一次转换结果被丢弃。第二次赋给 a，改变的是变量中的引用，而不是修改旧 String。

运行一个完整示例 · 02

构建标签并统计 Unicode 单位

对照文本组合与索引使用的单位。

public class Main {

    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        for (int day = 1; day <= 3; day++) {
            if (day > 1)
                builder.append(", ");
            builder.append("Day ").append(day);
        }
        System.out.println(builder.toString());
        String symbol = new String(Character.toChars(0x1F680));
        System.out.println("code units=" + symbol.length());
        System.out.println("code points=" + symbol.codePointCount(0, symbol.length()));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

Day 1, Day 2, Day 3
code units=2
code points=1

按执行顺序理解

1. 循环生成标签时有条件地追加分隔符。

2. 用 Character.toChars 创建补充码点。

3. 在相同完整字符串范围内比较 length 与 codePointCount。

逐步读懂代码

只有首个标签之后才加入分隔符，因此没有开头逗号。链式 append 作用于同一个构建器。

火箭码点在基本多文种平面之外，Java 用两个编码单元表示，而 codePointCount 返回一个码点。这并不意味着码点始终等于用户感知字符。

运行一个完整示例 · 01

保护容量不变式

测试成功、拒绝与独立实例状态。

public class Main {
    static final class Dispenser {
        private final int capacity;
        private int level;
        Dispenser(int capacity, int level) {
            if (capacity < 0 || level < 0 || level > capacity)
                throw new IllegalArgumentException("invalid state");
            this.capacity = capacity;
            this.level = level;
        }
        void fill(int amount) {
            if (amount < 0 || amount > capacity - level)
                throw new IllegalArgumentException("does not fit");
            level += amount;
        }
        int level() {
            return level;
        }
    }
    public static void main(String[] args) {
        Dispenser a = new Dispenser(12, 4);
        Dispenser b = new Dispenser(8, 0);
        a.fill(5);
        System.out.println("after fill=" + a.level());
        try {
            a.fill(4);
        } catch (IllegalArgumentException ex) {
            System.out.println("rejected");
        }
        System.out.println("after rejection=" + a.level());
        System.out.println("other instance=" + b.level());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

after fill=9
rejected
after rejection=9
other instance=0

按执行顺序理解

1. 构建字段彼此独立的两个有效实例。

2. 接受五单位，再拒绝四单位且不修改状态。

3. 读取两个实例，检查拒绝与隔离。

逐步读懂代码

构造器先建立不变式。每次 fill 在加法前检查剩余容量，从而保持规则。私有字段阻止调用者绕过操作直接写入。

被拒请求后 level 仍为九。第二实例仍为空，因为 level 是实例字段，而非共享静态状态。

运行一个完整示例 · 02

保护内部数组

通过刻意修改检查输入与输出别名。

import java.util.Arrays;

public class Main {
    static final class Snapshot {
        private final int[] values;
        Snapshot(int[] values) {
            this.values = values.clone();
        }
        int[] values() {
            return values.clone();
        }
    }
    public static void main(String[] args) {
        int[] supplied = {2, 5};
        Snapshot snapshot = new Snapshot(supplied);
        supplied[0] = 99;
        int[] exported = snapshot.values();
        exported[1] = 77;
        System.out.println("supplied=" + Arrays.toString(supplied));
        System.out.println("exported=" + Arrays.toString(exported));
        System.out.println("protected=" + Arrays.toString(snapshot.values()));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

supplied=[99, 5]
exported=[2, 77]
protected=[2, 5]

按执行顺序理解

1. 构造时复制数组，不保留调用者别名。

2. 暴露值时返回副本。

3. 两次外部编辑后，重新获取并打印内部值。

逐步读懂代码

构造器保存克隆，因此改 supplied 不影响快照。getter 返回另一个克隆，因此改 exported 也不影响快照。

对于基本类型整数单元，这已经足够。可变对象数组还需要更深的所有权规则。仅有 final 字段不能提供任一保护。

运行一个完整示例 · 03

保护成绩快照，隔离外部修改

米娜保存了三次测验成绩。她把数组传入报告对象，随后修改自己的工作数组，却发现报告也变了。private 没能阻止这个问题：两处引用指向同一个数组。于是她让构造器复制输入。接着她又发现，getter 也可能把内部数组交出去。在输出边界再复制一次，报告才成为稳定的快照。

import java.util.Arrays;
public class Main {
    static final class ScoreSnapshot {
        private final int[] scores;
        ScoreSnapshot(int[] source) {
            if (source == null) throw new IllegalArgumentException("missing scores");
            int[] copy = source.clone();
            for (int score : copy) {
                if (score < 0 || score > 100)
                    throw new IllegalArgumentException("score out of range");
            }
            scores = copy;
        }
        int[] values() { return scores.clone(); }
        int total() {
            int sum = 0;
            for (int score : scores) sum = Math.addExact(sum, score);
            return sum;
        }
    }
    public static void main(String[] args) {
        int[] input = {70, 80, 90};
        ScoreSnapshot report = new ScoreSnapshot(input);
        input[0] = 0;
        int[] exported = report.values();
        exported[1] = 0;
        assert report.total() == 240;
        System.out.println("snapshot: " + Arrays.toString(report.values()));
        System.out.println("total: " + report.total());
        try { new ScoreSnapshot(new int[]{101}); }
        catch (IllegalArgumentException error) { System.out.println("invalid score rejected"); }
        assert new ScoreSnapshot(new int[0]).total() == 0;
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

snapshot: [70, 80, 90]
total: 240
invalid score rejected

按执行顺序理解

1. 先复制，再保存。校验针对对象实际拥有的那份副本。

2. getter 再返回一份数组，修改返回值不会影响内部存储。

3. 分别修改两份外部数组，再核对报告，测试的是边界保护而非初始求和。

4. 拒绝 101；空数组的总分为零。addExact 会把整数溢出变成明确异常。

逐步读懂代码

不变量是：每个内部元素都在 0 到 100 之间。调用者接触不到内部数组，普通外部写入就无法破坏它。final 只禁止字段重新指向别的数组，不会冻结数组内容；真正提供保护的是两次复制。

n 个成绩的构造和每次 values() 都花费 O(n) 时间与 O(n) 新空间。total() 花费 O(n) 时间和 O(1) 辅助空间。这是为了稳定接口而付出的成本。int[] 的元素是基本类型，复制一层足够；若元素是可变对象，还要另行决定是否复制每个对象。

工程顺序：先写不变量，再确定谁拥有数据，最后测试所有接收或返回可变数据的边界。本例是单线程程序；如果源数组正被其他线程修改，复制不能代替同步。

运行一个完整示例 · 01

观察数字项之后的行

全部输入来自内存。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner("12\nlamp\n")) {
            int count = scanner.nextInt();
            String remainder = scanner.nextLine();
            String name = scanner.nextLine();
            System.out.println("count=" + count);
            System.out.println("remainder length=" + remainder.length());
            System.out.println("name=" + name);
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

count=12
remainder length=0
name=lamp

按执行顺序理解

1. 提供一行数字与下一行名称。

2. 读取数字项，并明确检查行的剩余部分。

3. 读取下一整行，再关闭自己的 scanner。

逐步读懂代码

nextInt 在数字后停止。第一次 nextLine 读取同一行剩下的空部分，下一次才读取 lamp。

资源型 try 关闭本地拥有的 scanner。这个程序刻意展示数字项与行混读；一致的逐行格式通常能避免该边界问题。

运行一个完整示例 · 02

验证完整设备记录

拒绝格式错误与负数量，同时保留有效记录。

import java.io.BufferedReader;
import java.io.StringReader;

public class Main {

    public static void main(String[] args) throws Exception {
        String data = "lamp,3\nchair,5\ndesk,many\nshelf,-2\n";
        int total = 0, lineNumber = 0;
        try (BufferedReader reader = new BufferedReader(new StringReader(data))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lineNumber++;
                String[] fields = line.split(",", -1);
                if (fields.length != 2 || fields[0].trim().isEmpty()) {
                    System.out.println("line " + lineNumber + ": bad structure");
                    continue;
                }
                try {
                    int count = Integer.parseInt(fields[1].trim());
                    if (count < 0) {
                        System.out.println("line " + lineNumber + ": negative count");
                        continue;
                    }
                    total += count;
                } catch (NumberFormatException ex) {
                    System.out.println("line " + lineNumber + ": bad integer");
                }
            }
        }
        System.out.println("accepted total=" + total);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

line 3: bad integer
line 4: negative count
accepted total=8

按执行顺序理解

1. 读取整行，并维护从一开始的行号。

2. 先检查结构，再做数值转换与领域验证。

3. 只累加被接受记录，报告确定的最终总量。

逐步读懂代码

readLine 仅在输入结束时返回 null。split 的 −1 保留末尾空字段，便于检查结构，避免掩盖缺失数量。

只有结构合法、解析成功且非负的记录才计入 total。本例数量很小，不会溢出；一般大型数据需要更宽累加器或受检查加法。

运行一个完整示例 · 01

写入再读取传感器记录

使用字节数组流，不需要文件。

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (DataOutputStream out = new DataOutputStream(bytes)) {
            out.writeInt(258);
            out.writeDouble(18.5);
        }
        byte[] record = bytes.toByteArray();
        System.out.println("bytes=" + record.length);
        try (DataInputStream in =
                 new DataInputStream(new ByteArrayInputStream(record))) {
            System.out.println("station=" + in.readInt());
            System.out.println("temperature=" + in.readDouble());
            System.out.println("at end=" + (in.read() == -1));
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

bytes=12
station=258
temperature=18.5
at end=true

按执行顺序理解

1. 按有名称、固定的顺序写字段。

2. 取出字节数组并检查完整大小。

3. 读取匹配类型并确认无剩余字节。

逐步读懂代码

写入顺序固定为 int、double。读取按相同顺序消耗四字节和八字节，最后 read 在内存流结束处返回 −1。

关闭 DataOutputStream 会刷新包装层，ByteArrayOutputStream 之后仍可取出字节。这样独立于文件系统验证基本类型布局。

运行一个完整示例 · 02

检查精确字节并拒绝截断

故意缩短副本，使 int 缺少一个必要字节。

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (DataOutputStream out = new DataOutputStream(bytes)) {
            out.writeInt(258);
        }
        byte[] full = bytes.toByteArray();
        StringBuilder hex = new StringBuilder();
        for (byte value : full) {
            if (hex.length() > 0)
                hex.append(' ');
            hex.append(String.format(java.util.Locale.ROOT, "%02X", value & 0xff));
        }
        System.out.println("hex=" + hex);
        byte[] shortRecord = java.util.Arrays.copyOf(full, 3);
        try (DataInputStream in =
                 new DataInputStream(new ByteArrayInputStream(shortRecord))) {
            in.readInt();
            System.out.println("unexpected complete record");
        } catch (EOFException ex) {
            System.out.println("truncated int rejected");
        }
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

hex=00 00 01 02
truncated int rejected

按执行顺序理解

1. 编码已知整数，并格式化各无符号字节。

2. 创建确定的三字节截断记录。

3. 仅捕获不完整基本类型读取产生的 EOFException。

逐步读懂代码

有符号 byte 与 0xff 按位与后得到无符号显示值。每个字节显示两位十六进制，顺序为 00 00 01 02。

三字节副本不足以表示完整 DataOutput int。处理器识别截断，不编造第四字节，也不吞掉其他 I/O 异常。

运行一个完整示例 · 01

表示事件、唯一值与计数

用同一输入序列展示三种不同契约。

import java.util.*;

public class Main {

    public static void main(String[] args) {
        List<String> arrivals = Arrays.asList("Mia", "Leo", "Mia");
        Set<String> unique = new HashSet<>(arrivals);
        Map<String, Integer> counts = new LinkedHashMap<>();
        for (String name : arrivals)
            counts.put(name, counts.getOrDefault(name, 0) + 1);
        System.out.println("events=" + arrivals);
        System.out.println("unique count=" + unique.size());
        System.out.println("counts=" + counts);
        counts.put("Mia", 3);
        System.out.println("after replacement=" + counts + ", keys=" + counts.size());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

events=[Mia, Leo, Mia]
unique count=2
counts={Mia=2, Leo=1}
after replacement={Mia=3, Leo=1}, keys=2

按执行顺序理解

1. 用 List 保留事件顺序，用 Set 得到唯一成员。

2. 为每个相等名称累计一个映射计数。

3. 替换一个关联，再检查键数不变。

逐步读懂代码

列表保留全部到达事件。这里只打印 HashSet 大小，未规定的集合顺序不会影响输出。LinkedHashMap 为显示的计数保留插入顺序。

getOrDefault 对新名称给零，put 保存增加后的计数。以后写入相等键只是替换值，不产生新逻辑键。

运行一个完整示例 · 02

用双端队列比较先入先出与后入先出

两个例子都使用端点操作，而非索引。

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Deque<String> queue = new ArrayDeque<>();
        queue.addLast("oak");
        queue.addLast("pine");
        queue.addLast("elm");
        StringJoiner fifo = new StringJoiner(", ");
        while (!queue.isEmpty())
            fifo.add(queue.removeFirst());
        Deque<String> stack = new ArrayDeque<>();
        stack.push("oak");
        stack.push("pine");
        stack.push("elm");
        StringJoiner lifo = new StringJoiner(", ");
        while (!stack.isEmpty())
            lifo.add(stack.pop());
        System.out.println("FIFO=" + fifo);
        System.out.println("LIFO=" + lifo);
        System.out.println("empty poll=" + queue.pollFirst());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

FIFO=oak, pine, elm
LIFO=elm, pine, oak
empty poll=null

按执行顺序理解

1. 从一端入队、另一端出队。

2. 在同一端压入与弹出，形成栈。

3. 比较要求非空的删除与空时返回标记的轮询。

逐步读懂代码

尾部加入、头部移除会保持到达顺序。push 与 pop 使用同一端，因此顺序反转。

removeFirst 要求非空，循环先检查。pollFirst 在空队列返回 null。ArrayDeque 拒绝 null 元素，因此这个标记没有歧义。

运行一个完整示例 · 01

用不可变座位作为值键

不同但相等的对象成为同一个逻辑集合成员。

import java.util.*;

public class Main {
    static final class Seat {
        private final String row;
        private final int number;
        Seat(String row, int number) {
            this.row = Objects.requireNonNull(row);
            this.number = number;
        }
        @Override
        public boolean equals(Object other) {
            if (this == other)
                return true;
            if (!(other instanceof Seat))
                return false;
            Seat seat = (Seat)other;
            return number == seat.number && row.equals(seat.row);
        }
        @Override
        public int hashCode() {
            return Objects.hash(row, number);
        }
    }
    public static void main(String[] args) {
        Seat a = new Seat("B", 7), b = new Seat("B", 7);
        Set<Seat> seats = new HashSet<>();
        seats.add(a);
        seats.add(b);
        seats.add(new Seat("B", 8));
        System.out.println("identity=" + (a == b));
        System.out.println("equal=" + a.equals(b));
        System.out.println("equal hashes=" + (a.hashCode() == b.hashCode()));
        System.out.println("logical seats=" + seats.size());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

identity=false
equal=true
equal hashes=true
logical seats=2

按执行顺序理解

1. 以 Object 参数定义相等，使容器调用正确重写。

2. 用恰好相等关系涉及的字段计算哈希。

3. 插入不同但相等的实例，检查逻辑成员数量。

逐步读懂代码

Seat 是 final，其相等字段稳定。equals 先处理同一对象、不相容类型，再比较两个逻辑字段。hashCode 使用相同字段。

虽然创建三个对象，集合大小为二。程序不打印集合遍历顺序，把相等行为与排序分开。

运行一个完整示例 · 02

区分哈希冲突的不等键

刻意使用差的哈希，仍保持正确相等关系。

import java.util.*;

public class Main {
    static final class Key {
        private final int id;
        Key(int id) {
            this.id = id;
        }
        @Override
        public boolean equals(Object other) {
            return other instanceof Key && id == ((Key)other).id;
        }
        @Override
        public int hashCode() {
            return 42;
        }
    }
    public static void main(String[] args) {
        Map<Key, String> values = new HashMap<>();
        values.put(new Key(1), "north");
        values.put(new Key(2), "south");
        values.put(new Key(1), "updated");
        System.out.println("keys=" + values.size());
        System.out.println("key 1=" + values.get(new Key(1)));
        System.out.println("key 2=" + values.get(new Key(2)));
        System.out.println("same hash=" +
                           (new Key(1).hashCode() == new Key(2).hashCode()));
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

keys=2
key 1=updated
key 2=south
same hash=true

按执行顺序理解

1. 以不可变整数编号定义相等。

2. 用常数哈希强制冲突。

3. 通过新建相等键查找各编号。

逐步读懂代码

两个编号都得到哈希 42，但 equals 仍区分一和二，所以两个映射都保留。再插入编号一，只替换与它相等的映射。

示例刻意不测耗时。合法但差的哈希只展示冲突下的正确性，不是推荐哈希策略。

运行一个完整示例 · 03

用值对象作为 Map 的键

机器人社用行号和列号标记地砖。米娜以一个地砖对象为键保存说明，之后创建了相同坐标的新对象，希望仍能找到说明。引用身份无法回答这个问题。她定义坐标相等，配套实现哈希函数，并保证键的坐标不会改变。

import java.util.HashMap;
import java.util.Map;
public class Main {
    static final class Cell {
        private final int row;
        private final int column;
        Cell(int row, int column) { this.row = row; this.column = column; }
        @Override public boolean equals(Object other) {
            if (this == other) return true;
            if (!(other instanceof Cell)) return false;
            Cell cell = (Cell) other;
            return row == cell.row && column == cell.column;
        }
        @Override public int hashCode() { return 31 * row + column; }
    }
    public static void main(String[] args) {
        Cell a = new Cell(2, 3);
        Cell b = new Cell(2, 3);
        Cell collision = new Cell(1, 34);
        Map<Cell, String> notes = new HashMap<>();
        notes.put(a, "charging");
        notes.put(collision, "door");
        assert a != b && a.equals(b) && b.equals(a);
        assert a.hashCode() == collision.hashCode();
        assert !a.equals(collision) && !a.equals(null);
        assert "charging".equals(notes.get(b));
        System.out.println("same object: " + (a == b));
        System.out.println("same value: " + a.equals(b));
        System.out.println("lookup: " + notes.get(b));
        System.out.println("collision keeps both: " + notes.size());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

same object: false
same value: true
lookup: charging
collision keeps both: 2

按执行顺序理解

1. 比较两个坐标，而不是内存身份。final 类避免子类引入不兼容的相等规则。

2. 哈希由 equals 使用的相同字段计算，因此相同坐标的哈希一致。

3. 故意让 (1,34) 与 (2,3) 冲突：哈希都是 65，但它们仍是不同的键。

4. 用从未插入的 b 查询。查询成功说明是按值查找。

逐步读懂代码

哈希先缩小查找范围，equals 再判断候选对象是否就是要找的键。正确方向是 a.equals(b) 成立时，二者 hashCode 必须相同。反过来不成立，示例中的冲突已经说明这一点。

公式 h = 31r + c 中，r 是行号，c 是列号。这只是教学用哈希，不是密码学哈希。Java int 运算可能回绕，但仍应保证相等值得到相同哈希。更好的分布能减少冲突，却无法让无限多种键在有限整数范围内完全无冲突。

键存入 Map 后，不要修改参与相等比较的字段。否则查询可能按新哈希查找，而条目仍留在原来的位置。不可变键可以避免这种失败；但不可变键不会让普通 HashMap 自动变成线程安全的容器。

运行一个完整示例 · 01

注入记录型协作者

不依赖外部输出服务，测试消息顺序。

import java.util.*;

public class Main {
    interface Sink {
        void send(String text);
    }
    static final class RecordingSink implements Sink {
        final List<String> messages = new ArrayList<>();
        public void send(String text) {
            messages.add(Objects.requireNonNull(text));
        }
    }
    static final class Reporter {
        private final Sink sink;
        Reporter(Sink sink) {
            this.sink = Objects.requireNonNull(sink);
        }
        void sendAll(List<String> messages) {
            for (String message : messages)
                sink.send(message);
        }
    }
    public static void main(String[] args) {
        RecordingSink sink = new RecordingSink();
        Reporter reporter = new Reporter(sink);
        reporter.sendAll(Arrays.asList("ready", "running", "done"));
        System.out.println(sink.messages);
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

[ready, running, done]

按执行顺序理解

1. 声明报告器需要的能力。

2. 通过接口传入具体记录实现。

3. 报告器委托完消息后，检查有序效果。

逐步读懂代码

Reporter 保存 Sink 接口而非具体输出设备。循环为每条消息委托一次 send。记录型实现让本地测试看到顺序。

测试替身拥有自己的列表。公开生产接口通常应返回受保护快照，而非暴露可变状态。本例重点是职责与替换。

运行一个完整示例 · 02

保持父类契约

命名计数器增加描述，同时保留有效计数操作。

public class Main {
    static class Counter {
        private int value;
        Counter(int start) {
            if (start < 0)
                throw new IllegalArgumentException();
            value = start;
        }
        void add(int amount) {
            if (amount < 0 || amount > Integer.MAX_VALUE - value)
                throw new IllegalArgumentException();
            value += amount;
        }
        int value() {
            return value;
        }
        String describe() {
            return "count=" + value;
        }
    }
    static final class NamedCounter extends Counter {
        private final String name;
        NamedCounter(String name, int start) {
            super(start);
            this.name = name;
        }
        @Override
        String describe() {
            return name + "=" + value();
        }
    }
    public static void main(String[] args) {
        Counter counter = new NamedCounter("samples", 2);
        counter.add(3);
        System.out.println(counter.describe());
        try {
            counter.add(-1);
        } catch (IllegalArgumentException ex) {
            System.out.println("negative rejected");
        }
        System.out.println("count=" + counter.value());
    }
}

javac -encoding UTF-8 Main.java
java -ea Main

samples=5
negative rejected
count=5

按执行顺序理解

1. 先初始化父类，再保存子类特有状态。

2. 通过父类型引用调用继承操作。

3. 重写展示行为，但不削弱状态不变式。

逐步读懂代码

super(start) 建立继承部分的有效计数。子类通过 value 读取，而非直接改变私有字段。重写只改变描述。

变量类型是 Counter，但实际接收者提供命名描述。add 保留父类检查，包括防溢出检查。