// 现代 Java 的气质：三行能跑，也能一句话建模
// —— 下面这些语法在 02–08 章逐个展开

sealed interface 事件 permits 升级, 下线 {}      // 07 章：把「一共就这几种」写进类型
record 升级(String 玩家, int 等级) implements 事件 {}
record 下线(String 玩家) implements 事件 {}

static String 播报(事件 e) {
    return switch (e) {                              // 08 章：模式匹配 + 解构
        case 升级(String p, int lv) when lv >= 100 -> p + " 满级了！";
        case 升级(String p, int lv)            -> p + " 升到 " + lv + " 级";
        case 下线(String p)                     -> p + " 走了";
    };                                              // 不用写 default：编译器知道就这两种
}

void main() {                                        // 01 章：JDK 25 起 main 可以这么短
    IO.println(播报(new 升级("小明", 100)));       // 小明 满级了！
}

// 这一页里例子的样子：一个人能做完、跑起来有反馈的东西

// ① 命令行小工具（03、19 章）—— 统计一个目录里各种后缀的文件数
Files.walk(Path.of("."))
     .filter(Files::isRegularFile)
     .collect(Collectors.groupingBy(Java::后缀, Collectors.counting()))

// ② 抓个接口做统计（11、19 章）—— HTTP 客户端在 JDK 里，不用装库
HttpClient.newHttpClient().send(req, BodyHandlers.ofString())

// ③ 文字游戏（05、07、08 章）—— 状态用 record 建模，回合用模式匹配分发
record 房间(String 描述, Map<String, 房间> 出口) {}

// ④ 桌面小程序（20 章）—— Swing 就在 JDK 里，一个文件就能出窗口
new JFrame("我的工具") {{ setVisible(true); }};

// ⑤ 一次抓一百个页面（14 章）—— 虚拟线程让并发写法退回到最好懂的那种
try (var pool = Executors.newVirtualThreadPerTaskExecutor()) {
    urls.forEach(u -> pool.submit(() -> 抓(u)));
}

Windows   winget install EclipseAdoptium.Temurin.25.JDK
macOS     brew install --cask temurin@25
Linux     sudo apt install openjdk-25-jdk        # 或用 SDKMAN!
任意平台   sdk install java 25-tem                # SDKMAN! 能装多版本并随时切换
手动      从 adoptium.net 下 zip/tar.gz 解压即用  # 不需要管理员权限

$ java -version
java version "25.0.1" 2025-10-21 LTS       // ① 能跑 Java 程序

$ javac -version
javac 25.0.1                               // ② 能编译 —— 这条不通就是只装了 JRE

$ jshell -version                          // ③ 有交互式环境（下一卡）

# 装完先确认这三个环境变量的状态（很多教程会让你手动设，其实通常不必）
$ java -version          # 这条通了，说明 PATH 已经对了
$ echo $JAVA_HOME        # 空着也没关系；只有部分构建工具需要它

# 想同时装多个版本，SDKMAN!（macOS/Linux/WSL）是最省事的
$ curl -s "https://get.sdkman.io" | bash
$ sdk list java          # 看有哪些发行版和版本
$ sdk install java 25-tem
$ sdk install java 21-tem
$ sdk use java 21-tem    # 只对当前终端生效
$ sdk default java 25-tem

# Windows 上的等价物：直接装两份，用时切 PATH
$ winget install EclipseAdoptium.Temurin.25.JDK
$ winget install EclipseAdoptium.Temurin.21.JDK

// ① 最短形式（JDK 25）：Hello.java
void main() {
    IO.println("你好，Java");
}

// ② 要读输入、要用命令行参数时（args 可选，写了就有）
void main(String[] args) {
    String 名字 = args.length > 0 ? args[0] : IO.readln("你叫什么？");
    IO.println("你好，" + 名字);
}

// ③ 完整形式：给别人当库用、要打包时写这种
public class Hello {
    public static void main(String[] args) {
        System.out.println("你好，Java");
    }
}

// 跑法（三种都试一遍，心里就有数了）
// $ java Hello.java              直接跑源文件
// $ javac Hello.java             先编译，产生 Hello.class
// $ java Hello                   再运行（注意：不带 .class 后缀）
// $ java Main.java               多文件也行，同目录的会一起编译

Hello.java:3: error: ';' expected           // 少分号：指着上一个 token 的末尾
        int x = "文本"
                    ^

E2.java:16: error: incompatible types: String cannot be converted to int
        int n = l.get(0);                   // 类型对不上：两边都写出来了

E5.java:4: error: variable y might not have been initialized
        return y;                           // 局部变量必须先赋值再用

Error: Could not find or load main class Appp     // 类名拼错，或 -cp 没指对

Exception in thread "main" java.lang.NullPointerException:
        Cannot invoke "String.length()" because "message" is null
    at N.main(N.java:4)

// 三类错误的最小复现，自己跑一遍会记得更牢

// ① 编译期：类型对不上
int x = "文本";              // incompatible types: String cannot be converted to int

// ② 启动期：类名拼错
// $ java Helo                 Error: Could not find or load main class Helo

// ③ 运行期：空指针
String message = null;
message.length();               // NPE: Cannot invoke "String.length()" because "message" is null

// 常见运行期异常与它们的意思（12 章展开）
// NullPointerException          用了 null
// ArrayIndexOutOfBoundsException 下标越界，消息里会带「Index 5 out of bounds for length 3」
// ClassCastException            强制转型转错了类型
// NumberFormatException         Integer.parseInt("12a") —— 消息里带原始字符串
// ArithmeticException: / by zero  整数除以零（浮点除以零不抛，得 Infinity）

// 想看英文原版报错（方便搜索）：
// $ javac -J-Duser.language=en X.java
// $ java  -Duser.language=en  X

// 基本类型：变量里就是值
int a = 10;
int b = a;        // 复制了一份值
b = 99;
// a 还是 10

// 引用类型：变量里是「指向对象的引用」
var 列表1 = new ArrayList<String>(List.of("a"));
var 列表2 = 列表1;   // 复制的是引用，对象只有一个
列表2.add("b");
// 列表1 现在也是 [a, b]

// 传参：传的是「引用的副本」
static void 试试(List<String> l) {
    l.add("外面看得见");      // ← 改的是同一个对象，外面看得见
    l = new ArrayList<>();     // ← 只是让局部变量指向别处，外面无感
    l.add("外面看不见");
}

// 装箱与拆箱
Integer 装箱 = 42;          // 自动装箱：Integer.valueOf(42)
int 拆箱 = 装箱;             // 自动拆箱：装箱.intValue()
List<Integer> 只能装对象 = List.of(1, 2, 3);   // List<int> 不合法

// 每种类型的字面量写法
long 大数 = 10_000_000_000L;   // 下划线只是给人看的分隔符
double 小数 = 1.5e3;          // 1500.0
int 十六进制 = 0xFF, 二进制 = 0b1010;
char 字符 = '中';

// var：右边说清楚了就用
var 名字 = "小明";                        // String
var 分数 = new HashMap<String, Integer>();     // 不用把长类型写两遍
var 行 = Files.readAllLines(路径);            // List<String>，读得出来

// var 用不了的地方
// var x;              编译错：需要初始值才能推断
// var y = null;       编译错：推不出类型
// var 不能用于字段、参数、返回类型

// 作用域：大括号就是边界
for (int i = 0; i < 3; i++) {
    int 临时 = i * 2;
}
// 这里 i 和 临时 都已经不存在了

// final 锁的是变量，不是对象
final List<String> 名单 = new ArrayList<>();
名单.add("小明");              // ✓ 合法：改的是对象内容
// 名单 = new ArrayList<>();  ✗ 编译错：不能重新赋值

// 常量：static final + 全大写（唯一被广泛遵守的命名约定）
static final int 最大重试次数 = 3;
static final String 版本 = "1.0";

Integer.MAX_VALUE + 1   →  -2147483648      // 悄悄变成最小值
Math.abs(Integer.MIN_VALUE) →  -2147483648   // 绝对值居然是负的

7 / 2    → 3        7 % 2   → 1
-7 / 2   → -3       -7 % 2  → -1       // 向零截断，余数跟着被除数的符号
1 / 0    → ArithmeticException: / by zero
1.0 / 0  → Infinity                    // 浮点除零不抛异常！
0.0 / 0.0 → NaN

0.1 + 0.2          → 0.30000000000000004
(0.1 + 0.2) == 0.3 → false
Double.NaN == Double.NaN → false        // NaN 不等于自己
new BigDecimal(0.1) → 0.1000000000000000055511151231257827021181583404541015625

// 溢出：静默 vs 响亮
int 静默 = Integer.MAX_VALUE + 1;              // -2147483648，不报错
int 响亮 = Math.addExact(Integer.MAX_VALUE, 1);  // ArithmeticException: integer overflow

// 时间戳用 long，不是 int
long 毫秒 = System.currentTimeMillis();          // int 只够表示 24 天

// 整数除法：想要小数得先转
int 完成 = 7, 总数 = 9;
int 错的 = 完成 / 总数 * 100;                    // 0 —— 先算 7/9 得 0
double 对的 = 100.0 * 完成 / 总数;                // 77.77…

// 浮点比较
double x = 0.1 + 0.2;
boolean 别这么写 = x == 0.3;                    // false
boolean 这么写 = Math.abs(x - 0.3) < 1e-9;      // true

// 钱：两种正确做法
var 单价 = new BigDecimal("19.99");              // ✓ 字符串构造
var 总价 = 单价.multiply(BigDecimal.valueOf(3));
// var 错的 = new BigDecimal(19.99);           ✗ 误差已经带进来了
long 分 = 1999;                                // ✓ 或者干脆用整数存最小单位

// 位运算（做标志位、哈希、图形时会用到）
int 与 = 0b1100 & 0b1010;   // 0b1000
int 左移 = 1 << 10;            // 1024
int 无符号右移 = -8 >>> 1;    // 2147483644（>> 保符号，>>> 补 0）

// 规则：基本类型 ==，其余 equals
int a = 1000, b = 1000;
System.out.println(a == b);            // true —— 基本类型比值

Integer x = 1000, y = 1000;
System.out.println(x == y);            // false！比的是对象身份
System.out.println(x.equals(y));       // true
System.out.println(x.intValue() == y);   // true —— 有一边是 int 就会拆箱比值

// 字符串永远用 equals
Scanner 输入 = new Scanner(System.in);
String 命令 = 输入.nextLine();
if (命令 == "退出") { }               // ✗ 永远是 false（运行期读进来的是新对象）
if ("退出".equals(命令)) { }          // ✓ 而且命令为 null 也不会炸
if (Objects.equals(命令, 目标)) { }     // ✓ 两边都可能为 null 时

// 自己的类：用 record 就自动有正确的 equals/hashCode
record 坐标(int x, int y) {}
var 集合 = new HashSet<坐标>();
集合.add(new 坐标(1, 2));
集合.add(new 坐标(1, 2));
System.out.println(集合.size());      // 1（换成普通 class 且没覆写 hashCode 就是 2）

int → long → float → double        // 自动，不用写
double → int                       // 必须强转，小数部分直接砍掉（不是四舍五入）

(int) 3.99      →  3               // 截断
(int) -3.99     →  -3              // 向零截断
(byte) 200      →  -56             // 超出范围就只留低 8 位
Math.round(3.5) →  4               // 要四舍五入用 Math.round

// 基本类型：自动 vs 强转
int i = 42;
long l = i;                 // 自动：不会丢
double d = l;              // 自动
int 回去 = (int) d;         // 必须强转：可能丢小数

double 价格 = 3.99;
System.out.println((int) 价格);          // 3 —— 截断，不是四舍五入
System.out.println(Math.round(价格));    // 4

// byte 是有符号的：处理二进制数据的标准写法
byte b = (byte) 200;                    // -56
int 当无符号看 = b & 0xFF;                // 200

// 引用类型：先检查再转（Java 16 起可以一步到位）
Object o = 读一个东西();
if (o instanceof String s && s.length() > 3) {   // s 直接可用，不用再强转
    System.out.println(s.toUpperCase());
}

// 老写法（还会在旧代码里见到）
if (o instanceof String) {
    String s = (String) o;               // 同一个类型写了三遍
}

// 字符串 ↔ 数字
int n = Integer.parseInt("42");
String s2 = String.valueOf(n);
try {
    int 用户输入 = Integer.parseInt(行);
} catch (NumberFormatException e) {
    System.out.println("这不是个数字：" + e.getMessage());
}

// 遍历：默认用增强 for
String[] 名单 = {"小明", "小红", "小刚"};
for (var 名字 : 名单) {
    System.out.println(名字);
}

// 需要下标时
for (int i = 0; i < 名单.length; i++) {
    System.out.printf("%d. %s%n", i + 1, 名单[i]);
}

// 跳出双层循环：用标签，不要用标志位
外层:
for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 9; j++) {
        if (棋盘[i][j] == 目标) {
            找到了 = true;
            break 外层;              // 一次跳出两层
        }
    }
}

// switch：箭头写法（不会贯穿，还能当表达式）
String 提示 = switch (等级) {
    case 1, 2, 3 -> "新手";
    case 4, 5    -> "熟练";
    default      -> "高手";
};

// 需要多行时用大括号 + yield
int 奖励 = switch (等级) {
    case 1 -> { 记录("新手奖励"); yield 100; }
    default -> 0;
};

// 短路求值：左边为假就不算右边
if (列表 != null && !列表.isEmpty()) { }   // 安全

// 一个方法的完整形态
static int 最大值(int a, int b) {     // 修饰符 返回类型 名字(参数)
    return a > b ? a : b;
}

// 重载：同名不同参
static int 最大值(int a, int b, int c) { return 最大值(最大值(a, b), c); }
static double 最大值(double a, double b) { return a > b ? a : b; }

// 可变参数：内部就是个数组
static int 求和(int... 数字) {
    int 和 = 0;
    for (int n : 数字) 和 += n;
    return 和;
}
求和();              // 0
求和(1, 2, 3);       // 6
求和(new int[]{1, 2}); // 3 —— 直接传数组也行

// 递归：树形结构上最自然
static long 目录大小(File 目录) {
    if (目录.isFile()) return 目录.length();
    long 合计 = 0;
    for (File 子 : 目录.listFiles()) 合计 += 目录大小(子);
    return 合计;
}

// 重载挑选的经典坑
List<Integer> 列表 = new ArrayList<>(List.of(10, 20, 30));
列表.remove(1);                      // 删下标 1 → [10, 30]
列表.remove(Integer.valueOf(10));      // 删值 10 → [30]

// 三种创建方式
int[] a = new int[5];                 // 五个 0
int[] b = {3, 1, 4, 1, 5};             // 直接给内容
int[] c = new int[]{3, 1, 4};          // 需要当参数传时用这种

System.out.println(b.length);           // 5 —— 字段，没有括号
System.out.println(b);                  // [I@5fd9b663 ← 没用
System.out.println(Arrays.toString(b));   // [3, 1, 4, 1, 5] ← 要这个

// 常用操作
Arrays.sort(b);                            // 原地排序
int[] 大一点 = Arrays.copyOf(b, 10);        // 扩容（多出来的补 0）
int[] 一段 = Arrays.copyOfRange(b, 1, 3);  // 下标 [1,3)
Arrays.fill(a, -1);                       // 全部填 -1
int 和 = Arrays.stream(b).sum();           // 转 Stream（11 章）

// 二维：棋盘、迷宫、图像
char[][] 棋盘 = new char[3][3];
for (char[] 行 : 棋盘) Arrays.fill(行, '.');
棋盘[1][1] = 'X';
for (char[] 行 : 棋盘) System.out.println(new String(行));

// 数组 ↔ 集合
List<String> 列表 = List.of(名单);                     // 数组 → 不可变 List
List<String> 可改 = new ArrayList<>(List.of(名单));
String[] 回去 = 列表.toArray(new String[0]);            // List → 数组

// 注意：基本类型数组转 List 有坑
int[] 原始 = {1, 2, 3};
// List.of(原始).size() 是 1！整个数组被当成了一个元素
List<Integer> 对的 = Arrays.stream(原始).boxed().toList();

// 一个命令行工具的完整骨架（JDK 25 紧凑写法，直接 java 这个文件.java 就能跑）
import java.nio.file.*;
import java.util.*;

void main(String[] args) throws Exception {
    // ① 参数检查：不合法就说清用法并给非 0 退出码
    if (args.length == 0) {
        System.err.println("用法：java 统计.java <文件>");
        System.exit(2);
    }
    var 路径 = Path.of(args[0]);

    // ② 可能失败的操作要处理失败（12 章）
    if (!Files.exists(路径)) {
        System.err.println("找不到文件：" + 路径.toAbsolutePath());
        System.exit(1);
    }

    // ③ 干活
    var 行 = Files.readAllLines(路径);
    int 字符数 = 0, 非空行 = 0;
    for (var l : 行) {
        字符数 += l.length();
        if (!l.isBlank()) 非空行++;
    }

    // ④ 结果打到 stdout，格式化对齐
    System.out.printf("%-10s %d%n", "总行数", 行.size());
    System.out.printf("%-10s %d%n", "非空行", 非空行);
    System.out.printf("%-10s %d%n", "字符数", 字符数);
}

// 交互式版本（JDK 25 的 IO 类）
void 猜数字() {
    int 答案 = (int) (Math.random() * 100) + 1;
    for (int 次数 = 1; ; 次数++) {
        int 猜 = Integer.parseInt(IO.readln("猜一个 1-100 的数："));
        if (猜 == 答案) { IO.println("对了！用了 " + 次数 + " 次"); return; }
        IO.println(猜 < 答案 ? "小了" : "大了");
    }
}

String s = "hello";
s.toUpperCase();              // 返回值被丢掉了，s 还是 "hello"
s = s.toUpperCase();          // ✓ 必须接住返回值

// 不可变：所有"修改"都返回新对象
String 原文 = "  Hello Java  ";
String 结果 = 原文.strip()            // "Hello Java"
                 .toLowerCase()      // "hello java"
                 .replace(' ', '-');  // "hello-java"
// 原文 还是 "  Hello Java  "

// 常量池：这些结果验证过
String a = "hi", b = "hi";
a == b                        // true  —— 同一个常量
a == new String("hi")         // false —— new 强制造新的
a == new String("hi").intern() // true  —— intern 把它换成池里那个
a == ("h" + "i")             // true  —— 编译期就拼好了
String p = "h";
a == (p + "i")               // false —— 运行期拼接，新对象

// 所以：内容比较一律 equals
a.equals(b)                    // true，永远可靠
a.equalsIgnoreCase("HI")      // true

// 空与空白的四种判断，别搞混
"".isEmpty()                  // true  —— 长度为 0
"   ".isEmpty()               // false —— 有三个空格
"   ".isBlank()               // true  —— 只有空白字符（Java 11 起）
// 变量可能为 null 时：s == null || s.isBlank()

// 查找与判断
String 文件名 = "报告.2026.pdf";
文件名.endsWith(".pdf")              // true
文件名.indexOf(".")                  // 2（找不到会返回 -1）
文件名.lastIndexOf(".")              // 7 —— 取后缀要用这个
文件名.substring(文件名.lastIndexOf(".") + 1)   // "pdf"

// split 的参数是正则，这是最常见的误用
"a.b.c".split(".")                // 空数组！. 在正则里是"任意字符"
"a.b.c".split("\\.")              // [a, b, c] ✓
"a, b,c".split(",\\s*")            // [a, b, c] —— 顺手处理空格

// 拼接：用 join，别用循环
String.join(", ", List.of("小明", "小红"))   // "小明, 小红"
String.join(System.lineSeparator(), 行列表)   // 按平台换行拼

// 格式化
String.format("%-10s %6.2f %,d", "苹果", 3.5, 1234567);
// "苹果          3.50 1,234,567"
"你好，%s！".formatted(名字);          // Java 15 起
System.out.printf("%d 项%n", n);       // %n 而不是 \n

// 画个分隔线
System.out.println("─".repeat(40));

// 按行处理多行文本
文本.lines()
    .filter(l -> !l.isBlank())
    .map(String::strip)
    .forEach(System.out::println);

// ✓ 单句拼接：放心用 +，编译器会合成一次操作
String 消息 = "用户 " + 名字 + " 得分 " + 分数 + " 分";

// ✗ 循环里累积：O(n²)
String 结果 = "";
for (var 行 : 一万行) {
    结果 += 行 + "\n";              // 每次都复制一遍已有内容
}

// ✓ 用 StringBuilder
var sb = new StringBuilder();
for (var 行 : 一万行) {
    sb.append(行).append('\n');      // append 返回自己，可以链式
}
String 结果2 = sb.toString();

// ✓✓ 更好：交给 Stream（11 章）
String 结果3 = 一万行.stream().collect(Collectors.joining("\n"));
String 结果4 = String.join("\n", 一万行);      // 更直接

// StringBuilder 的其它常用方法
sb.insert(0, "开头");
sb.reverse();
sb.setLength(0);                 // 清空复用
sb.deleteCharAt(sb.length() - 1);  // 去掉最后一个分隔符

// 已知大概长度时预分配，能少几次扩容
var sb2 = new StringBuilder(1024);

// 多行 JSON：不用转义引号，不用 \n
String 请求体 = """
    {
      "名字": "小明",
      "技能": ["Java", "画画"],
      "等级": 3
    }
    """;
// 公共缩进（4 空格）被自动剥掉，内部的 2 空格缩进保留

// 多行 SQL
String 查询 = """
    select 名字, count(*) as 次数
      from 记录
     where 日期 >= ?
     group by 名字
     order by 次数 desc
    """;

// 游戏里的多行提示
IO.println("""
    ┌──────────────┐
    │  猜数字游戏  │
    └──────────────┘
    输入 1-100 的数字，q 退出""");   // 三引号接在内容后 = 末尾没有换行

// 配合 formatted 当模板用
String 邮件 = """
    你好，%s：
      你的分数是 %d 分。
    """.formatted(名字, 分数);

// 行尾反斜杠：续行（换行符不生效）
String 长句 = """
    这是很长的一句话，\
    在源码里折了行，实际上是一行。""";

// 要保留行尾空格：用 \s
String 对齐 = """
    左边   \s
    右边""";

// 三个"长度"是三回事
String s = "👍中";
s.length()                                    // 3 —— UTF-16 码元数
s.codePointCount(0, s.length())              // 2 —— 字符数
s.getBytes(StandardCharsets.UTF_8).length     // 7 —— 字节数

// ✗ 按 char 遍历：emoji 会被拆成两半
for (int i = 0; i < s.length(); i++) {
    System.out.println(s.charAt(i));    // 前两个都是乱码
}

// ✓ 按码位遍历
s.codePoints().forEach(cp ->
    System.out.println(new String(Character.toChars(cp))));

// ✓ 更彻底：按"用户感知的一个字符"切（能正确处理肤色修饰符等）
var 切分器 = BreakIterator.getCharacterInstance();
切分器.setText(s);

// 编码转换：一律显式指定
byte[] 字节 = s.getBytes(StandardCharsets.UTF_8);
String 回来 = new String(字节, StandardCharsets.UTF_8);
Files.writeString(路径, s, StandardCharsets.UTF_8);

// 中文排序：不要用默认的 compareTo（那是按码位）
var 按拼音 = Collator.getInstance(Locale.CHINA);
名单.sort(按拼音);                          // "赵钱孙李" 排出来才是拼音序

// 看清楚系统给你的默认值（排查乱码时第一步）
System.out.println(System.getProperty("file.encoding"));    // UTF-8（Java 18+）
System.out.println(System.getProperty("stdout.encoding"));  // 跟随系统

// 一个完整的类
public class 玩家 {
    // 字段：每个对象各有一份，一律 private
    private final String 名字;      // final = 造出来就不能再变
    private int 血量;
    private final List<String> 背包 = new ArrayList<>();

    // 主构造器：所有初始化逻辑集中在这里
    public 玩家(String 名字, int 血量) {
        if (名字 == null || 名字.isBlank())
            throw new IllegalArgumentException("名字不能为空");  // 12 章
        this.名字 = 名字;         // this 区分字段与参数
        this.血量 = 血量;
    }

    // 便捷构造器：委托给主构造器（必须是第一句）
    public 玩家(String 名字) {
        this(名字, 100);
    }

    // 方法：对内部数据的操作
    public void 受伤(int 点数) {
        血量 = Math.max(0, 血量 - 点数);   // 内部保证不变量：血量不为负
    }

    public boolean 活着() { return 血量 > 0; }

    // 只读访问：返回副本，别把内部列表交出去（见本章第 4 卡）
    public List<String> 背包() { return List.copyOf(背包); }

    // toString：调试时会救你的命
    @Override public String toString() {
        return "玩家[" + 名字 + " 血量=" + 血量 + "]";
    }
}

// 用它
var p = new 玩家("小明");
p.受伤(30);
System.out.println(p);        // 玩家[小明 血量=70]

// ✓ 常量
public class 配置 {
    public static final int 最大玩家数 = 8;
    public static final Path 存档目录 = Path.of("saves");
}
配置.最大玩家数           // 不用 new，直接用类名访问

// ✓ 工具方法：不依赖任何对象状态
public class 距离 {
    public static double 欧氏(double x1, double y1, double x2, double y2) {
        return Math.hypot(x2 - x1, y2 - y1);
    }
    private 距离() {}      // 私有构造器：明确表示"这个类不该被 new"
}

// ✓ 工厂方法：比构造器灵活
public class 玩家 {
    public static 玩家 新手(String 名字) { return new 玩家(名字, 100); }
    public static 玩家 从存档(String 行) { /* 解析 */ }
    // 两个都返回玩家，但名字说清了区别（构造器做不到这一点）
}

// ✗ 可变的静态字段 = 全局变量
public class 计分 {
    public static int 总分 = 0;      // 谁都能改、多线程会错、测试之间会串
}

// 静态初始化块：类第一次被用到时跑一次（15 章讲触发时机）
public class 词典 {
    private static final Map<String, String> 表;
    static {
        表 = new HashMap<>();
        表.put("hello", "你好");   // 需要多行逻辑才能初始化时用它
    }
}

[1] Base 静态块              // 类第一次被用到时，父类静态先跑
[2] Sub 静态块               // 然后子类静态
[3] Base 实例块              // 从这里开始每次 new 都跑
[4] Base 构造器
[5'] Sub.init 被父类构造器调用，此时 name=null   // ← 危险区！
[6] Sub 实例块，name=小明
[7] Sub 构造器，name=小明

// 上面那段输出对应的代码
class Base {
    static { System.out.println("[1] Base 静态块"); }
    { System.out.println("[3] Base 实例块"); }
    Base() {
        System.out.println("[4] Base 构造器");
        init();                  // ← 危险：调用了可被覆写的方法
    }
    void init() { System.out.println("[5] Base.init"); }
}

class Sub extends Base {
    static { System.out.println("[2] Sub 静态块"); }
    private String name = "小明";
    { System.out.println("[6] Sub 实例块，name=" + name); }
    Sub() {
        super();               // 不写也会自动调用（且必须是第一句）
        System.out.println("[7] Sub 构造器，name=" + name);
    }
    @Override void init() {
        System.out.println("[5'] name=" + name);   // null！
    }
}

// ✓ 安全的写法：构造器里只调不可覆写的方法
class 安全的 {
    private final String 名字;
    安全的(String 名字) {
        this.名字 = 校验(名字);      // private，子类改不了
    }
    private static String 校验(String s) {
        return Objects.requireNonNull(s, "名字不能为空");
    }
}

// 用 record 写不可变类（07 章展开），加一个紧凑构造器做防御性拷贝
record 队伍(String 名称, List<String> 成员) {
    队伍 {                                  // 紧凑构造器：校验 + 规范化
        Objects.requireNonNull(名称);
        成员 = List.copyOf(成员);              // ← 关键：拷进来，切断外部引用
    }
    // 需要"改"就返回新对象
    队伍 加人(String 人) {
        var 新成员 = new ArrayList<>(成员);
        新成员.add(人);
        return new 队伍(名称, 新成员);
    }
}

// 没有防御性拷贝会发生什么
var 原始 = new ArrayList<>(List.of("小明"));
var 队 = new 队伍("一队", 原始);
原始.add("偷偷加的");
// 有 List.copyOf：队.成员() 是 [小明]      ✓
// 没有的话：       队.成员() 是 [小明, 偷偷加的]  ✗

// 传统 class 的写法（record 之前都这么写）
public final class 坐标 {
    private final int x, y;
    public 坐标(int x, int y) { this.x = x; this.y = y; }
    public int x() { return x; }
    public 坐标 右移(int d) { return new 坐标(x + d, y); }   // 返回新的
}

// 输出时也要小心：别把内部集合直接交出去
class 背包 {
    private final List<String> 物品 = new ArrayList<>();
    public List<String> 物品() { return 物品; }              // ✗ 谁都能改
    public List<String> 物品副本() { return List.copyOf(物品); }  // ✓
}

// ✓ 静态嵌套类：表达"这个类属于那个类"
public class 迷宫 {
    public static record 格子(int 行, int 列) {}   // 迷宫.格子

    private final 格子[][] 地图;
}

// 非静态内部类：能访问外部字段，但也拖着外部对象
public class 链表 {
    private int 长度;
    class 迭代器 {                  // 没有 static
        boolean 还有() { return 位置 < 长度; }   // 直接用外部的 长度
    }
}
var 表 = new 链表();
var it = 表.new 迭代器();       // 创建语法都不一样

// 匿名类 → lambda 的演进（同一件事的三代写法）
// ① 匿名类（Java 7 及以前）
按钮.addActionListener(new ActionListener() {
    @Override public void actionPerformed(ActionEvent e) {
        System.out.println("点了");
    }
});
// ② lambda（Java 8 起）
按钮.addActionListener(e -> System.out.println("点了"));
// ③ 方法引用（更短的情况下）
按钮.addActionListener(this::处理点击);

// 匿名类仍然需要的场合：要实现多个方法
文件.addWatcher(new Watcher() {
    @Override public void onCreate(Path p) { }
    @Override public void onDelete(Path p) { }   // 两个方法，lambda 做不到
});

// 多态：同一个调用落到不同实现上
abstract class 图形 {
    abstract double 面积();                  // 没有实现，子类必须给
    String 描述() { return getClass().getSimpleName() + " 面积 " + 面积(); }
}
class 圆 extends 图形 {
    private final double r;
    圆(double r) { this.r = r; }
    @Override double 面积() { return Math.PI * r * r; }
}
class 矩形 extends 图形 {
    private final double w, h;
    矩形(double w, double h) { this.w = w; this.h = h; }
    @Override double 面积() { return w * h; }
}

List<图形> 一堆 = List.of(new 圆(1), new 矩形(2, 3));
for (var g : 一堆) System.out.println(g.描述());   // 各调各的 面积()

// super：在父类行为上加东西
class 带日志的圆 extends 圆 {
    @Override double 面积() {
        double a = super.面积();
        System.out.println("算了一次面积：" + a);
        return a;
    }
}

// @Override 的价值：拼错时编译器会拦住你
class 错的 extends 图形 {
    // @Override double 面机() { ... }   ← 加了注解会报错
    double 面机() { return 0; }        // 不加注解：静默变成一个新方法
    @Override double 面积() { return 0; }
}

// 不打算被继承的类，写 final
public final class 工具 { }

// 定义能力
interface 可存档 {
    String 存成文本();                   // 抽象方法：实现类必须给

    default void 存到文件(Path p) throws IOException {   // 默认方法
        Files.writeString(p, 存成文本());
    }

    static 可存档 空的() { return () -> ""; }   // 静态工厂
}

record 存档(String 玩家, int 关卡) implements 可存档 {
    @Override public String 存成文本() { return 玩家 + "," + 关卡; }
    // 存到文件 直接白拿
}

// 一个类可以实现多个接口
class 关卡 implements 可存档, Comparable<关卡>, AutoCloseable {
    @Override public int compareTo(关卡 其它) { return Integer.compare(编号, 其它.编号); }
    @Override public void close() { 释放资源(); }   // 12 章的 try-with-resources
    @Override public String 存成文本() { return ""; }
}

// 两个接口有同名默认方法：必须自己决定
interface A { default String hi() { return "A"; } }
interface B { default String hi() { return "B"; } }
class AB implements A, B {
    @Override public String hi() { return A.super.hi() + "+" + B.super.hi(); }
}
// new AB().hi() → "A+B"

// 好习惯：声明用接口，实现只出现在 new 的那一行
List<String> 名单 = new ArrayList<>();      // 左边接口，右边实现
Map<String, Integer> 分数 = new HashMap<>();

// 场景一：只定义契约 → 接口
interface 存储 {
    void 保存(String 键, String 值);
    Optional<String> 读取(String 键);
}
class 内存存储 implements 存储 { }
class 文件存储 implements 存储 { }
// 调用方只认接口，随时能换实现（也方便测试时塞个假的）

// 场景二：子类要共享状态 → 抽象类
abstract class 怪物 {
    protected int 血量;                    // 字段：接口给不了
    protected final String 名字;

    protected 怪物(String 名字, int 血量) {    // 构造器：接口也给不了
        this.名字 = 名字; this.血量 = 血量;
    }
    public void 受伤(int d) { 血量 -= d; }   // 所有怪物共享这段逻辑
    public abstract int 攻击力();            // 各自不同
}
class 史莱姆 extends 怪物 {
    史莱姆() { super("史莱姆", 20); }
    @Override public int 攻击力() { return 3; }
}

// 场景三：一共就这几种 → 密封接口（07、08 章）
sealed interface 棋子 permits 兵, 車, 馬 {}
record 兵(boolean 过河) implements 棋子 {}

// 标准库的三层套路：接口 + 骨架 + 实现
// interface List<E>  →  abstract class AbstractList<E>  →  class ArrayList<E>

// ✗ 继承：拿到了不想要的全部 API
class 计数列表<E> extends ArrayList<E> {
    private int 添加次数;
    @Override public boolean add(E e) { 添加次数++; return super.add(e); }
    @Override public boolean addAll(Collection<? extends E> c) {
        添加次数 += c.size(); return super.addAll(c);   // 如果 addAll 内部调了 add，就数了两遍！
    }
}
// 这个 bug 取决于 ArrayList 的内部实现，而那是随时可能变的

// ✓ 组合 + 委托：只暴露你想要的
class 计数集合<E> {
    private final List<E> 内部 = new ArrayList<>();   // 有一个，而不是是一个
    private int 添加次数;

    public void 添加(E e) { 内部.add(e); 添加次数++; }
    public int 大小() { return 内部.size(); }        // 需要什么转发什么
    public int 添加次数() { return 添加次数; }
    public List<E> 快照() { return List.copyOf(内部); }
    // clear()、remove() 这些没转发 = 使用者根本调不到，计数不会被绕过
}

// 组合还让"换实现"变成一行的事
class 游戏 {
    private final 存储 存档;                       // 依赖接口
    游戏(存储 存档) { this.存档 = 存档; }         // 谁用谁决定用哪个实现
}
new 游戏(new 文件存储());       // 正式跑
new 游戏(new 内存存储());       // 测试时（这就是"依赖注入"的全部内核）

// 装饰：一层套一层地加能力，标准库到处在用
var 流 = new BufferedReader(new InputStreamReader(System.in));

// ✓ 最省事：record 自动全都对
record 坐标(int x, int y) {}
new 坐标(1,2).equals(new 坐标(1,2))     // true
new 坐标(1,2).toString()                  // 坐标[x=1, y=2]

// 手写版本（必须成对，且基于同一组字段）
public final class 坐标2 {
    private final int x, y;

    @Override public boolean equals(Object o) {     // 参数必须是 Object！
        if (this == o) return true;                // 快速路径
        return o instanceof 坐标2 其它                // 08 章的模式匹配，顺带处理了 null
            && x == 其它.x && y == 其它.y;
    }

    @Override public int hashCode() {
        return Objects.hash(x, y);                  // 和 equals 用同一组字段
    }

    @Override public String toString() {
        return "坐标2[" + x + ", " + y + "]";
    }
}

// ✗ 只覆写 equals 的后果
class 坏例子 {
    final int v;
    @Override public boolean equals(Object o) { return o instanceof 坏例子 b && b.v == v; }
    // 没有 hashCode
}
var 集 = new HashSet<坏例子>();
集.add(new 坏例子(1));
集.add(new 坏例子(1));
集.size()      // 2 —— equals 说相等，但它们进了不同的桶

// 可变字段参与 hashCode 的后果
var 集2 = new HashSet<可变的>();
var 对象 = new 可变的("旧名字");
集2.add(对象);
对象.改名("新名字");
集2.contains(对象)   // false！它还在集合里，但按新哈希找不到了

// 一行顶过去二十行
record 坐标(int x, int y) {}

// 加校验：紧凑构造器（没有参数列表）
record 分数(String 科目, int 分) {
    分数 {                                   // ← 注意没有 (String 科目, int 分)
        Objects.requireNonNull(科目);
        if (分 < 0 || 分 > 100)
            throw new IllegalArgumentException("分数要在 0-100 之间：" + 分);
        科目 = 科目.strip();                    // 规范化：赋给参数即可，编译器会写进字段
    }
}

// 加方法、加静态工厂、实现接口
record 矩形(double 宽, double 高) implements Comparable<矩形> {
    static 矩形 正方形(double 边) { return new 矩形(边, 边); }
    double 面积() { return 宽 * 高; }
    boolean 是正方形() { return 宽 == 高; }
    @Override public int compareTo(矩形 o) { return Double.compare(面积(), o.面积()); }
}

// 方法要返回两个值？以前得造个类或用数组，现在一行
record 统计(int 最小, int 最大, double 平均) {}
static 统计 分析(int[] 数据) { return new 统计(..., ..., ...); }

// 局部 record：只在一个方法里用的临时结构
void 排行() {
    record 条目(String 名字, int 分) {}       // 就在方法里定义
    名单.stream()
        .map(p -> new 条目(p.名字(), p.算分()))
        .sorted(Comparator.comparingInt(条目::分).reversed())
        .forEach(System.out::println);
}

// 访问器没有 get 前缀
var p = new 坐标(3, 4);
p.x()          // ✓ 3
// p.getX()  ✗ 不存在

// 最简单的枚举
enum 方向 { 上, 下, 左, 右 }

// 带字段：每个常量附带数据
enum 难度 {
    简单(0.5, "新手村"),
    普通(1.0, "标准体验"),
    地狱(2.5, "自找苦吃");              // 注意这里是分号

    private final double 倍率;
    private final String 说明;

    难度(double 倍率, String 说明) {        // 构造器自动是 private
        this.倍率 = 倍率; this.说明 = 说明;
    }
    public double 倍率() { return 倍率; }
    public int 算伤害(int 基础) { return (int) (基础 * 倍率); }
}
难度.地狱.算伤害(100)          // 250

// 带行为：每个常量有自己的实现
enum 运算 {
    加("+") { public int 算(int a, int b) { return a + b; } },
    乘("*") { public int 算(int a, int b) { return a * b; } };

    final String 符号;
    运算(String s) { 符号 = s; }
    public abstract int 算(int a, int b);   // 加新常量时编译器强制你实现
}
for (var op : 运算.values())
    System.out.printf("3 %s 4 = %d%n", op.符号, op.算(3, 4));

// 常用 API
方向.values()              // [上, 下, 左, 右]
方向.上.ordinal()          // 0
方向.上.name()             // "上"
方向.valueOf("上")         // 方向.上（名字不存在会抛 IllegalArgumentException）
方向.上 == 方向.valueOf("上")   // true —— 枚举可以放心用 ==

// 专用集合
var 计数 = new EnumMap<方向, Integer>(方向.class);
var 允许 = EnumSet.of(方向.上, 方向.下);

// switch 上枚举：不用写枚举类名前缀
String 箭头 = switch (d) {
    case 上 -> "↑";  case 下 -> "↓";
    case 左 -> "←";  case 右 -> "→";
};                                    // 四个都写了，不需要 default

// 密封接口 + record：一共就这三种形状
sealed interface 形状 permits 圆, 矩形, 三角 {}
record 圆(double r) implements 形状 {}
record 矩形(double 宽, double 高) implements 形状 {}
record 三角(double a, double b, double c) implements 形状 {}

// switch 不需要 default —— 编译器知道就这三种（08 章展开）
static double 面积(形状 s) {
    return switch (s) {
        case 圆 c        -> Math.PI * c.r() * c.r();
        case 矩形 r       -> r.宽() * r.高();
        case 三角 t       -> 海伦公式(t);
    };
}
// 现在往 permits 里加一个"梯形"：上面这个 switch 立刻编译错，
// 报 the switch expression does not cover all possible input values（报错原文）

// 场景：操作结果（比 null 和异常都清楚）
sealed interface 结果<T> permits 成功, 失败 {}
record 成功<T>(T 值) implements 结果<T> {}
record 失败<T>(String 原因, int 代码) implements 结果<T> {}

结果<String> r = 读配置();
String 提示 = switch (r) {
    case 成功<String>(String v) -> "读到了：" + v;
    case 失败<String>(String 因, int 码) -> "失败(" + 码 + ")：" + 因;
};

// 场景：表达式求值器（教科书例子，写起来终于不难看了）
sealed interface 表达式 {}
record 数(double 值) implements 表达式 {}
record 加(表达式 左, 表达式 右) implements 表达式 {}
record 乘(表达式 左, 表达式 右) implements 表达式 {}
// 同一个文件里时 permits 可以省略

static double 求值(表达式 e) {
    return switch (e) {
        case 数(double v)      -> v;
        case 加(var l, var r) -> 求值(l) + 求值(r);
        case 乘(var l, var r) -> 求值(l) * 求值(r);
    };
}
求值(new 加(new 数(2), new 乘(new 数(3), new 数(4))))   // 14.0

// ① 建模：一共就这几种指令
enum 方向 { 北, 南, 东, 西 }

sealed interface 指令 {}
record 移动(方向 往) implements 指令 {}
record 拿取(String 物品) implements 指令 {}
record 看() implements 指令 {}
record 退出() implements 指令 {}

// ② 解析：字符串 → 指令（只在这里碰字符串）
static Optional<指令> 解析(String 行) {
    String[] 词 = 行.strip().toLowerCase(Locale.ROOT).split("\\s+");
    return switch (词[0]) {
        case "go", "走"   -> 方向解析(词).map(移动::new);
        case "take", "拿" -> 词.length > 1
                             ? Optional.of(new 拿取(词[1]))
                             : Optional.empty();
        case "look", "看" -> Optional.of(new 看());
        case "quit", "退出" -> Optional.of(new 退出());
        default          -> Optional.empty();
    };
}

// ③ 执行：直接拿解构出来的数据，不碰字符串
boolean 执行(指令 指令, 游戏 游戏) {
    switch (指令) {
        case 移动(方向 往)   -> 游戏.走(往);
        case 拿取(String 物) -> 游戏.拿(物);
        case 看 ignored     -> IO.println(游戏.当前房间().描述());
        case 退出 ignored   -> { return false; }
    }                              // 没有 default：加新指令时这里会编译错
    return true;
}

// 主循环
void main() {
    var 游戏 = new 游戏();
    while (true) {
        var 行 = IO.readln("> ");
        var 指令 = 解析(行);
        if (指令.isEmpty()) { IO.println("听不懂。试试 go/take/look/quit"); continue; }
        if (!执行(指令.get(), 游戏)) break;
    }
}

// ① 数据类：旧写法（网上教程的典型样子）
public class 坐标Old {
    private int x;
    private int y;
    public 坐标Old() {}
    public 坐标Old(int x, int y) { this.x = x; this.y = y; }
    public int getX() { return x; }
    public void setX(int x) { this.x = x; }
    public int getY() { return y; }
    public void setY(int y) { this.y = y; }
    @Override public boolean equals(Object o) { /* 十行 */ }
    @Override public int hashCode() { return Objects.hash(x, y); }
    @Override public String toString() { /* 三行 */ }
}
// 今天：
record 坐标(int x, int y) {}

// ② 常量：旧写法
public static final int 难度_简单 = 0;
public static final int 难度_普通 = 1;
void 开始(int 难度) { }        // 传 999 也能编译
// 今天：
void 开始(难度 难度) { }       // 只能传那三个值之一

// ③ 分发：旧写法（instanceof 链，最糟的一种）
static double 面积Old(Object s) {
    if (s instanceof 圆) {
        圆 c = (圆) s;                       // 类型写三遍
        return Math.PI * c.r() * c.r();
    } else if (s instanceof 矩形) {
        矩形 r = (矩形) s;
        return r.宽() * r.高();
    }
    throw new IllegalArgumentException("不认识的形状");   // 运行期才发现漏了
}
// 今天：漏一种编译就报错
static double 面积(形状 s) {
    return switch (s) {
        case 圆(double r) -> Math.PI * r * r;
        case 矩形(var w, var h) -> w * h;
        case 三角 t -> 海伦公式(t);
    };
}

// 旧写法：类型写三遍
if (o instanceof String) {
    String s = (String) o;
    if (s.length() > 3) { ... }
}

// 新写法
if (o instanceof String s && s.length() > 3) { ... }

// 基本形式
Object o = 拿一个东西();
if (o instanceof String s) {
    System.out.println(s.toUpperCase());   // s 直接可用
}

// 带条件
if (o instanceof String s && s.length() > 3) { }

// 提前返回（很常用的写法）
void 处理(Object o) {
    if (!(o instanceof String s)) return;
    // 这里往下 s 都能用
    System.out.println(s.strip());
}

// 写 equals 的标准姿势（一行同时做四件事）
@Override public boolean equals(Object o) {
    return o instanceof 坐标 其它 && x == 其它.x && y == 其它.y;
    // null 检查 ✓ 类型检查 ✓ 强转 ✓ 比较 ✓
}

// record 模式：直接解构（Java 21 起）
if (o instanceof 坐标(int x, int y)) {
    System.out.println(x + "," + y);        // 连访问器都不用调
}

// 嵌套解构
record 线段(坐标 起, 坐标 终) {}
if (o instanceof 线段(坐标(var x1, var y1), 坐标(var x2, var y2))) {
    System.out.println(Math.hypot(x2 - x1, y2 - y1));
}

// null 的行为
Object 空 = null;
空 instanceof String          // false —— 永远不会 NPE

// 完整形态：类型 + 守卫 + 解构 + 穷尽（这段跑过）
sealed interface 形状 permits 圆, 矩形, 三角 {}
record 圆(double r) implements 形状 {}
record 矩形(double 宽, double 高) implements 形状 {}
record 三角(double a, double b, double c) implements 形状 {}

String 描述(形状 s) {
    return switch (s) {
        case 圆 c when c.r() > 10      -> "大圆 " + c.r();   // 守卫要写在前面
        case 圆(double r)               -> "圆 " + r;         // 解构
        case 矩形(var w, var h) when w == h -> "正方形 " + w;
        case 矩形 r                    -> "矩形 " + r.宽() + "x" + r.高();
        case 三角 t                    -> "三角形";
    };                                // 没有 default：密封类型已穷尽
}

// null 必须显式处理（不写 case null 会抛 NPE）
String 安全描述(形状 s) {
    return switch (s) {
        case null          -> "没有形状";
        case 圆 c          -> "圆";
        case 矩形 r         -> "矩形";
        case 三角 t         -> "三角";
    };
}

// 混合常量与类型（处理来自外部的 Object）
String 格式化(Object o) {
    return switch (o) {
        case null                    -> "(空)";
        case Integer i when i < 0    -> "负数 " + i;
        case Integer i               -> "整数 " + i;
        case Double d                -> "%.2f".formatted(d);
        case String s when s.isBlank() -> "(空白字符串)";
        case String s                -> "\"" + s + "\"";
        case int[] a                  -> Arrays.toString(a);
        default                      -> o.toString();   // Object 不密封，必须兜底
    };
}

// 当语句用（不返回值）时也可以
switch (事件) {
    case 点击(var x, var y) -> 处理点击(x, y);
    case 按键(var 码)      -> 处理按键(码);
}

// ✗ 老写法的三个毛病都在这
String 结果;                          // 毛病二：得先声明
switch (等级) {
    case 1:
        String 说明 = "入门";            // 毛病三：这个变量在下面也"可见"
        结果 = "新手";
        // 毛病一：这里忘了 break，会掉进 case 2
    case 2:
        结果 = "熟练";
        break;
    default:
        结果 = "未知";
}

// ✓ 新写法
String 结果2 = switch (等级) {
    case 1       -> "新手";
    case 2, 3    -> "熟练";         // 多个值用逗号，意图明确
    default      -> "未知";
};

// 多行逻辑：大括号 + yield
int 奖励 = switch (等级) {
    case 1 -> {
        记录("发放新手奖励");
        yield 100;                   // 不是 return！
    }
    case 2 -> 50;
    default -> 0;
};

// 枚举 + 箭头 + 不写 default = 加新常量时编译器提醒你（07 章）
enum 状态 { 待办, 进行中, 完成 }
String 图标 = switch (状态) {
    case 待办   -> "○";
    case 进行中 -> "◐";
    case 完成   -> "●";
};

// 老代码里确实需要贯穿的场景，新写法这样表达
int 天数 = switch (月) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11           -> 30;
    case 2                      -> 闰年(年) ? 29 : 28;
    default -> throw new IllegalArgumentException("月份不对：" + 月);
};

// ① 匹配嵌套结构：一次匹配整条路径
Object 配置 = 解析(文本);   // 得到嵌套的 Map/List/String/Integer

// 老写法：五层判断
if (配置 instanceof Map) {
    Object 服务器 = ((Map<?, ?>) 配置).get("服务器");
    if (服务器 instanceof Map) {
        Object 端口 = ((Map<?, ?>) 服务器).get("端口");
        if (端口 instanceof Integer p && p > 0) { 用(p); }
    }
}

// 用 record 建模之后：一行
sealed interface 节点 {}
record 对象(Map<String, 节点> 项) implements 节点 {}
record 数组(List<节点> 元素) implements 节点 {}
record 文本(String 值) implements 节点 {}
record 数字(double 值) implements 节点 {}

String 渲染(节点 n) {
    return switch (n) {
        case 文本(String v)   -> "\"" + v + "\"";
        case 数字(double v)   -> String.valueOf(v);
        case 数组(List<节点> 元素) ->
            元素.stream().map(this::渲染).collect(Collectors.joining(",", "[", "]"));
        case 对象(Map<String, 节点> 项) ->
            项.entrySet().stream()
              .map(e -> "\"" + e.getKey() + "\":" + 渲染(e.getValue()))
              .collect(Collectors.joining(",", "{", "}"));
    };
}

// ② 状态机：每个状态带自己的数据
sealed interface 下载状态 {}
record 待开始(String 地址) implements 下载状态 {}
record 进行中(String 地址, long 已下载, long 总量) implements 下载状态 {}
record 已完成(Path 文件, Duration 耗时) implements 下载状态 {}
record 已失败(String 原因, int 重试次数) implements 下载状态 {}

String 显示(下载状态 s) {
    return switch (s) {
        case 待开始(var 地址)              -> "等待中 " + 地址;
        case 进行中(var a, var 已, var 总) when 总 > 0
                                          -> "%.1f%%".formatted(100.0 * 已 / 总);
        case 进行中 p                     -> "已下载 " + p.已下载() + " 字节";
        case 已完成(var 文件, var 耗时)     -> "完成 " + 文件.getFileName();
        case 已失败(var 因, var n) when n >= 3 -> "放弃：" + 因;
        case 已失败(var 因, var n)        -> "失败（第 " + n + " 次）：" + 因;
    };
}
// 注意：进行中 才有进度，已完成 才有文件路径 —— 不需要一堆可能为 null 的字段

List 名单 = new ArrayList();
名单.add("小明");
名单.add(42);                    // 编译器不管
String s = (String) 名单.get(1);  // 运行期 ClassCastException

// 日常用法：把类型写清楚
List<String> 名单 = new ArrayList<>();
名单.add("小明");
// 名单.add(42);            ✗ 编译错：incompatible types
String 第一个 = 名单.get(0);     // 不用强转

// 嵌套泛型
Map<String, List<Integer>> 分数表 = new HashMap<>();
分数表.computeIfAbsent("小明", k -> new ArrayList<>()).add(95);

// 增强 for 也受益：不用强转
for (String 名 : 名单) { }

// 泛型方法：调用时通常不用显式写类型（编译器推断）
List<String> 空的 = Collections.emptyList();
Optional<Integer> 也许有 = Optional.of(42);

// var 与泛型：右边必须写全
var 对的 = new HashMap<String, Integer>();   // HashMap<String, Integer>
var 坑 = new HashMap<>();                     // HashMap<Object, Object>！

// 基本类型不能当类型参数，得用包装类型（02 章）
// List<int>      ✗
List<Integer> 数字 = List.of(1, 2, 3);        // ✓
int[] 更省内存 = {1, 2, 3};                    // 大量数字时用数组

// 泛型类：一个简单的结果包装
public record 结果<T>(T 值, String 错误) {
    public static <T> 结果<T> 成功(T 值) { return new 结果<>(值, null); }
    public static <T> 结果<T> 失败(String 错) { return new 结果<>(null, 错); }
    public boolean 成功了() { return 错误 == null; }
    // 静态方法必须自己声明 <T>：类上那个属于实例
}
结果<Integer> r = 结果.成功(42);      // 类型自动推断

// 泛型方法：<T> 写在返回类型前
static <T> T 第一个或默认(List<T> 列表, T 默认值) {
    return 列表.isEmpty() ? 默认值 : 列表.get(0);
}
String s = 第一个或默认(名单, "无");        // 返回类型跟着参数走

// 有界类型：加了界限才能调它的方法
static <T extends Comparable<T>> T 最大(List<T> 列表) {
    T 最大值 = 列表.get(0);
    for (T x : 列表)
        if (x.compareTo(最大值) > 0) 最大值 = x;   // 没有界限时这行编译不过
    return 最大值;
}

// 多个类型参数
static <K, V> Map<V, K> 反转(Map<K, V> 原) {
    var 新的 = new HashMap<V, K>();
    原.forEach((k, v) -> 新的.put(v, k));
    return 新的;
}

// 一个真会用到的泛型类：定长缓存
class 最近使用<K, V> extends LinkedHashMap<K, V> {
    private final int 上限;
    最近使用(int 上限) { super(16, 0.75f, true); this.上限 = 上限; }
    @Override protected boolean removeEldestEntry(Map.Entry<K, V> 最老) {
        return size() > 上限;      // 超了自动淘汰最久未用的
    }
}

List<String> l = new ArrayList<>();
List raw = l;                  // 原始类型，编译器只给一个 unchecked 警告
raw.add(42);                   // 塞进去了！
l.size()      → 1              // 列表里真的有一个元素
String s = l.get(0);           // ClassCastException: Integer cannot be cast to String

// 擦除的证据
new ArrayList<String>().getClass() == new ArrayList<Integer>().getClass()
// true —— 运行期只有一个 ArrayList

// 堆污染：错误出现在离根因很远的地方
List<String> l = new ArrayList<>();
((List) l).add(42);            // 警告：unchecked call to add(E)
String s = l.get(0);           // ← 这里才炸：ClassCastException

// 绕过"不能 new T()"：传工厂进来
static <T> List<T> 造几个(int n, Supplier<T> 工厂) {
    var 结果 = new ArrayList<T>();
    for (int i = 0; i < n; i++) 结果.add(工厂.get());
    return 结果;
}
造几个(3, ArrayList::new);

// 绕过"不能 instanceof List<String>"
if (o instanceof List<?> 列表) {          // ✓ 只能问"是不是 List"
    // 元素类型只能自己逐个检查
    if (!列表.isEmpty() && 列表.get(0) instanceof String) { }
}

// 需要运行期类型信息时：显式传 Class
static <T> T 读配置(Path p, Class<T> 类型) {
    // 库都是这么做的：Jackson 的 readValue(json, User.class)
    return 类型.cast(解析(p));
}

// 泛型可变参数：会有警告，确认安全后才加注解
@SafeVarargs
static <T> List<T> 列表(T... 元素) {    // T... 内部是 T[]，而 T[] 是"泛型数组"
    return List.of(元素);
}

// 问题：这个方法只能接受 List<Number>，传 List<Integer> 编译错
static double 求和差(List<Number> 列表) { }
// 求和差(List.of(1, 2, 3));   ✗ List<Integer> 不是 List<Number>

// ✓ 生产者用 extends：我只从它那儿读
static double 求和(List<? extends Number> 列表) {
    double 和 = 0;
    for (Number n : 列表) 和 += n.doubleValue();   // 读：没问题
    // 列表.add(1);   ✗ 不能写：编译器不知道它到底是哪种数字的列表
    return 和;
}
求和(List.of(1, 2.5, 3L));      // 6.5—— 混着几种数字都行

// ✓ 消费者用 super：我只往里面写
static void 填数(List<? super Integer> 目标) {
    目标.add(1);
    目标.add(2);                       // 写：没问题
    Object o = 目标.get(0);              // 读出来只能当 Object
}
List<Number> n = new ArrayList<>();
填数(n);                        // ✓ 得到 [1, 2]

// 标准库的经典例子：一读一写，两边正好相反
// Collections.copy(List<? super T> dest, List<? extends T> src)
// Stream.map(Function<? super T, ? extends R> mapper)

// Comparator 也是典型：它消费元素
static <T> void 排序(List<T> 列表, Comparator<? super T> 比较器) { }
// 这样一个 Comparator<Object> 也能拿来排 List<String>

// 只关心结构不关心类型：无界通配符
static void 打印大小(Collection<?> c) {
    System.out.println(c.size());
}

// 既读又写：不用通配符，用类型参数
static <T> void 交换(List<T> 列表, int i, int j) {
    T 临时 = 列表.get(i);
    列表.set(i, 列表.get(j));
    列表.set(j, 临时);
}

// 读懂签名的练习：把通配符划掉再读
<R> Stream<R> map(Function<? super T, ? extends R> f)
// 划掉后： Stream<R> map(Function<T, R> f)  —— "拿一个 T->R 的函数，得到 Stream<R>"

<T> Optional<T> reduce(BinaryOperator<T> 累加器)
// "拿两个 T 合成一个 T 的函数，可能得到一个 T"（空流就没有）

<K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> 分类)
// 中间那个 ? 是内部累加类型，用的人不用管 —— 划掉读：
// "拿一个 T->K 的分类函数，得到 Map<K, List<T>>"

// ✓ 该用泛型：容器
class 环形缓冲<T> {
    private final Object[] 数据;          // 内部用 Object[]，这是标准做法
    private int 头, 尾;
    环形缓冲(int 容量) { 数据 = new Object[容量]; }

    void 放(T x) { 数据[尾++ % 数据.length] = x; }

    @SuppressWarnings("unchecked")          // 这个抑制是有理由的：只有放进去的才取得出
    T 取() { return (T) 数据[头++ % 数据.length]; }
}

// ✗ 不该用泛型：只有一种类型会用
static <T extends CharSequence> int 数一数(T 文本) { return 文本.length(); }
static int 数一数(String 文本) { return 文本.length(); }        // ✓ 这样就够了

// 公开 API 的参数：加 ? extends 让调用方更自由
public void 添加全部(Collection<? extends 玩家> 一批) { }
// 调用方可以传 List<VIP玩家>、Set<新手玩家>…

// 默认三件套
List<String> 顺序表 = new ArrayList<>();
Set<String> 去重表 = new HashSet<>();
Map<String, Integer> 映射 = new HashMap<>();

// 队列与栈：都用 ArrayDeque
Deque<String> 队列 = new ArrayDeque<>();
队列.addLast("先来的");      // 入队
队列.pollFirst();             // 出队（空时返回 null，不抛异常）

Deque<String> 栈 = new ArrayDeque<>();
栈.push("后进");              // 压栈（等于 addFirst）
栈.pop();                    // 弹栈（空时抛 NoSuchElementException）

// 优先队列：每次取出最小的（做 Dijkstra、任务调度、Top-K）
var 堆 = new PriorityQueue<任务>(Comparator.comparingInt(任务::优先级));
堆.add(new 任务("洗碗", 3));
堆.poll();                   // 优先级最小的那个

// 需要保持插入顺序的 Set / Map
Set<String> 有序去重 = new LinkedHashSet<>();   // 去重且记得先来后到
Map<String, Integer> 有序映射 = new LinkedHashMap<>();

// 需要按键排序
TreeMap<String, Integer> 排序映射 = new TreeMap<>();
排序映射.firstKey();            // TreeMap 独有：最小键
排序映射.headMap("m");          // 范围查询

// 快速构造（Java 9 起）——注意得到的是不可变集合
var 三个 = List.of("a", "b", "c");
var 表 = Map.of("一", 1, "二", 2);
var 可改的 = new ArrayList<>(List.of("a", "b"));   // 要能改就再包一层

// 计数：merge 是最短的正确写法
var 词频 = new HashMap<String, Integer>();
for (var 词 : 所有词) {
    词频.merge(词, 1, Integer::sum);      // 没有就放 1，有就加 1
}
// 老写法：
// 词频.put(词, 词频.getOrDefault(词, 0) + 1);   也对，但 merge 更直接

// 一对多：computeIfAbsent
var 分组 = new HashMap<Character, List<String>>();
for (var 名 : 名单) {
    分组.computeIfAbsent(名.charAt(0), c -> new ArrayList<>()).add(名);
}
// 老写法要三行：if (!分组.containsKey(k)) 分组.put(k, new ArrayList<>()); 分组.get(k).add(名);

// 读取：三种兜底方式
int 分数 = 表.getOrDefault("小明", 0);      // 不写回（调用后表还是空的）
表.putIfAbsent("小明", 0);                 // 写回，但已有值时不动
int 分数2 = 表.computeIfAbsent("小明", k -> 0);  // 写回并返回

// 遍历
表.forEach((名, 分) -> System.out.printf("%s: %d%n", 名, 分));

for (var 项 : 表.entrySet()) {         // 需要 break 时用这个
    if (项.getValue() > 90) { System.out.println(项.getKey()); break; }
}

// 按值排序输出前十（很常见的需求）
词频.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .limit(10)
    .forEach(e -> System.out.printf("%-15s %d%n", e.getKey(), e.getValue()));

// HashMap 允许 null 键和 null 值，但 Map.of 不允许
表.put(null, 1);                        // ✓ HashMap 可以
// Map.of(null, 1);                     ✗ NullPointerException

// ✗ 危险：结果取决于删的是哪个位置
var 列表 = new ArrayList<>(List.of("a", "b", "c"));
for (String x : 列表) {
    if (x.equals("b")) 列表.remove(x);      // 删 b：静默成功；删 a：抛 CME
}

// ✓ 首选：removeIf
列表.removeIf(x -> x.equals("b"));
列表.removeIf(String::isBlank);
列表.removeIf(p -> p.血量() <= 0);        // 游戏循环里清理死亡单位

// ✓ 需要在删除时做别的事：显式迭代器
var it = 列表.iterator();
while (it.hasNext()) {
    var x = it.next();
    if (该删(x)) {
        记录("删除了 " + x);
        it.remove();                     // 用迭代器自己的 remove
    }
}

// ✓ 边遍历边加：不能改原集合，收集到新的
var 新增 = new ArrayList<String>();
for (var x : 列表) {
    if (要分裂(x)) 新增.add(x + "-副本");
}
列表.addAll(新增);                       // 循环结束后一起加

// ✓ 最安全：不改原集合，产生新的（11 章）
var 活着的 = 列表.stream().filter(p -> p.血量() > 0).toList();

// Map 上的删除
表.entrySet().removeIf(e -> e.getValue() < 60);
表.values().removeIf(Objects::isNull);

// 链式构造比较器：读起来像自然语言
名单.sort(Comparator
    .comparingInt(玩家::分数).reversed()      // 分数从高到低
    .thenComparing(玩家::名字));                // 分数相同按名字

// 按多个键，其中一个可能为 null
名单.sort(Comparator.comparing(玩家::公会,
        Comparator.nullsLast(Comparator.naturalOrder())));

// 自然顺序：元素自己实现 Comparable
record 版本(int 主, int 次) implements Comparable<版本> {
    @Override public int compareTo(版本 o) {
        return 主 != o.主 ? Integer.compare(主, o.主)
                          : Integer.compare(次, o.次);
        // 用 Integer.compare 而不是 主 - o.主 —— 后者会溢出
    }
}
Collections.sort(版本列表);        // 用自然顺序

// 不改原列表：走 Stream
var 排好的 = 名单.stream()
    .sorted(Comparator.comparing(玩家::名字))
    .toList();

// 排序 + 取前 N（Top-K 的标准写法）
var 前十 = 名单.stream()
    .sorted(Comparator.comparingInt(玩家::分数).reversed())
    .limit(10)
    .toList();

// 中文按拼音排（04 章）
名单.sort(Comparator.comparing(玩家::名字, Collator.getInstance(Locale.CHINA)));

// 数组排序
int[] 数字 = {3, 1, 2};
Arrays.sort(数字);                          // 基本类型：只能自然顺序
Arrays.sort(对象数组, Comparator.comparing(...));  // 对象数组：可以给比较器