控制流

学习目标

完成本文学习后，读者应能够在以下 Bloom 认知层级上达成对应目标：

• 记忆（Memory）：复述 Java 控制流的五大基本结构（顺序、分支、循环、跳转、异常）；列举 if-else、switch、for、while、do-while、break、continue、return、try-catch-finally、assert 的语法形式；说出 Java 5 至 Java 21 在控制流方向引入的关键特性。
• 理解（Understand）：解释 switch 表达式与 switch 语句的本质区别；阐述异常处理机制中 try-with-resources 的资源释放顺序；说明 break 与带标签 break 在控制流转移上的差异；理解 assert 与 if 检查在语义和运行时行为上的不同。
• 应用（Apply）：使用卫语句（guard clause）重构深层嵌套的条件分支；运用 switch 表达式与 yield 简化状态映射逻辑；通过 try-with-resources 管理多个 AutoCloseable 资源；使用带标签的 break 跳出多层循环。
• 分析（Analyze）：对比 if-else 链与 switch 在可读性、可维护性、JIT 优化潜力上的差异；剖析 finally 块中 return 语句吞掉异常的根因；分析异常表（exception table）如何决定 try-catch 的执行路径。
• 评价（Evaluate）：评估给定业务场景应使用受检异常（checked exception）还是非受检异常（unchecked exception）；判断循环中是否应提取循环不变量（loop invariant）；权衡 assert 在生产代码中的适用边界。
• 创造（Create）：设计基于状态机（state machine）与 switch 表达式的订单流程编排；实现自定义 AutoCloseable 资源池；编写可读性高且防御性强的参数校验流水线。

历史动机与背景

控制流的起源与理论根基

“控制流”（control flow）一词最早可追溯至 1966 年 Corrado Böhm 与 Giuseppe Jacopini 发表的《Flow Diagrams, Turing Machines and Languages with Only Two Formation-Rules》。该论文证明：任意复杂的程序逻辑都可由顺序（sequence）、选择（selection）、**迭代（iteration）**三种基本结构表达，这一结论被称为”结构化程序定理”（Structured Program Theorem）。它直接推动了 1968 年 Edsger Dijkstra 著名的《Go To Statement Considered Harmful》一文，宣告了结构化编程时代的到来。

Java 在 1995 年诞生时即遵循结构化编程理念：废弃 goto（虽保留为关键字但未启用），以 if-else、switch、for、while、do-while、break、continue、return、try-catch-finally 构建控制流体系。这一设计哲学使 Java 程序更易读、易维护、易分析。

Java 控制流的演进时间线

为什么控制流设计如此重要

控制流是程序的”骨架”，其设计直接影响代码的可读性、可维护性、正确性与性能。一项由 Microsoft Research 于 2018 年发布的实证研究显示：开发者阅读代码时约 60% 的时间用于理解控制流路径。控制流设计的三大目标：

1. 降低圈复杂度：Thomas McCabe 于 1976 年提出的圈复杂度（cyclomatic complexity）度量 $V(G) = E - N + 2P$，其中 $E$ 为控制流图边数，$N$ 为节点数，$P$ 为连通分量数。圈复杂度超过 10 的方法缺陷率显著上升。
2. 减少分支预测失败：现代 CPU 的分支预测器（branch predictor）对可预测的分支模式有 95%+ 的命中率，但不可预测的分支（如 if (random() > 0.5)）会导致流水线冲刷，性能下降 10-30%。
3. 支持编译器优化：JIT 编译器（如 HotSpot 的 C2、Graal）依赖控制流图（CFG）进行内联、逃逸分析、循环展开等优化。简单清晰的控制流使优化器更易识别优化机会。

真实事故案例

控制流设计缺陷曾导致多起重大生产事故：

• Ariane 5 火箭爆炸（1996）：将 64 位浮点数转换为 16 位有符号整数时未做异常保护，触发 OverflowError，导致惯性导航系统失效，火箭偏离轨道后自毁，损失 5 亿美元。
• Therac-25 医疗辐射事故（1986）：并发条件竞争导致 if 分支误判，患者接受超剂量辐射，造成多人死亡。
• Java 大型电商支付故障（2014）：finally 块中 return 吞掉 try 块抛出的业务异常，导致订单状态与支付状态不一致，最终需对账补偿。

这些案例警示：控制流不仅是语法问题，更是工程严谨性问题。

形式化定义

控制流图

控制流图（Control Flow Graph, CFG）是程序的图形化表示，定义为四元组：

其中：

• $N$：节点集，每个节点对应一个基本块（basic block），即一段顺序执行、无内部跳转的指令序列。
• $E \subseteq N \times N$：有向边集，$(n_i, n_j) \in E$ 表示控制流可从 $n_i$ 转移到 $n_j$。
• $n_{\text{entry}} \in N$：入口节点。
• $n_{\text{exit}} \in N$：出口节点。

Java 的每种控制流构造对应特定的 CFG 子图模式：

圈复杂度

McCabe 圈复杂度定义为：

其中 $P$ 为连通分量数（对单入口单出口的方法，$P = 1$）。等价地：

决策点包括 if、for、while、do-while、case、catch、&&、||、?: 等。经验阈值：

• $V(G) \leq 10$：低风险，易于测试。
• $10 < V(G) \leq 20$：中风险，需谨慎设计。
• $V(G) > 20$：高风险，应重构。

异常语义的形式化

Java 异常机制可形式化为带异常的求值规则。设表达式 $e$ 的求值结果为 $\langle v, \sigma' \rangle$（值与新状态）或 $\text{throw}(t, \sigma')$（抛出类型为 $t$ 的异常与新状态）：

异常传播规则：若 try 块求值抛出异常 $t$，且存在 catch 子句匹配 $t \preceq T_k$（$t$ 是 $T_k$ 的子类型），则控制流转入该 catch 块；否则异常继续向外层传播。

switch 表达式的穷尽性

Java 17+ 的 switch 表达式要求穷尽性（exhaustiveness）：所有可能的输入值都必须有对应分支。形式化地，设 $S$ 为选择器类型，$C_k$ 为各 case 标签覆盖的值集，则：

对于密封类（sealed class）$S = \text{sealed } C \text{ permits } A, B, C$，switch 表达式需覆盖 $A$、$B$、$C$ 三种子类（或包含 default），否则编译失败。这使编译器能在新增子类时强制开发者更新所有 switch，避免遗漏分支。

happens-before 与控制流

Java 内存模型（JMM）中 happens-before 关系与控制流紧密相关。对同一监视器锁 $m$：

这意味着 synchronized 块内的所有写操作对下一个获取锁的线程可见。控制流中的 return、throw、break、continue 都会触发 monitorexit，从而建立 happens-before 边。

理论推导

if-else 与 switch 的性能模型

JVM 对 if-else 与 switch 采用不同的底层实现策略：

if-else 链编译为一系列条件跳转指令：

// if (x == 1) {...} else if (x == 2) {...} else {...}
iload_1
iconst_1
if_icmpne L1
// x == 1 分支
goto L_end
L1: iload_1
iconst_2
if_icmpne L2
// x == 2 分支
goto L_end
L2: // else 分支
L_end:

平均比较次数为 $O(n)$，其中 $n$ 为分支数。

switch 语句在 case 值密集时编译为 tableswitch（跳转表），稀疏时编译为 lookupswitch（二分查找）：

tableswitch
  low: 1
  high: 3
  L1 // case 1
  L2 // case 2
  L3 // case 3
  default: L_default

tableswitch 的时间复杂度为 $O(1)$，lookupswitch 为 $O(\log n)$。因此当 case 值连续且数量较多时，switch 显著优于 if-else 链。

经验阈值：

• 分支数 $\leq 3$：if-else 与 switch 性能差异可忽略。
• 分支数 $4 \leq n \leq 10$：switch 略优。
• 分支数 $> 10$：switch 显著优于 if-else，且可读性更佳。

try-catch-finally 的异常表机制

JVM 通过异常表（exception table）而非显式跳转指令实现 try-catch。每个 try 块对应异常表中一行记录：

含义：若 PC 在 $[\text{start}, \text{end})$ 范围内抛出类型为 $\text{type}$（或其子类）的异常，则跳转到 $\text{handler}$。

异常处理的性能特征：

1. 未抛出异常时：try 块几乎零开销（HotSpot 采用”零成本异常”策略，仅在抛出时才构建栈轨迹）。
2. 抛出异常时：构建异常对象需遍历栈帧填充 StackTraceElement，开销约 1-10 微秒。
3. finally 块：编译器将 finally 代码内联到每个正常出口和异常出口，因此 finally 块在字节码层面可能出现多次。

推导 finally 总会执行的语义：

设 try 块 $T$、catch 块 $C$、finally 块 $F$。控制流可能路径：

• $T$ 正常结束 $\to F$ 执行 $\to$ 方法返回。
• $T$ 抛异常 $\to C$ 捕获 $\to C$ 正常结束 $\to F$ 执行 $\to$ 方法返回。
• $T$ 抛异常 $\to C$ 未捕获 $\to F$ 执行 $\to$ 异常继续传播。
• $T$ 或 $C$ 中 return $\to F$ 执行 $\to$ 方法返回（finally 的 return 会覆盖原 return）。

形式化：

break 与 continue 的控制流转移

break 与 continue 在字节码层面编译为 goto 指令。带标签的 break/continue 只是跳转目标不同：

带标签的 break 是 Java 中唯一能从内层循环直接跳出多层的方式（不使用异常或标志位）。其语义清晰且无副作用，优于手动 boolean 标志。

assert 与 if 的运行时差异

assert 语句在字节码层面受 assertionsEnabled 标志保护：

// assert condition : detail;
getstatic Test.assertionsEnabled
ifne L_check
goto L_end
L_check:
// 计算 condition
ifeq L_throw
goto L_end
L_throw:
new AssertionError
// 计算 detail
invokespecial AssertionError.<init>
athrow
L_end:

关键差异：

• 默认禁用：assert 默认不启用（-ea 参数启用），生产环境几乎零开销。
• 抛出 AssertionError：assert 失败抛出 AssertionError（非受检），不应被捕获。
• 不可恢复：assert 用于不变量校验，失败意味着程序逻辑错误，无法恢复。

因此 assert 不应替代参数校验（参数校验应抛 IllegalArgumentException 等可处理异常）。

异常处理的开销模型

异常抛出与捕获的开销可建模为：

• $T_{\text{alloc}}$：分配 Throwable 对象，约 100-500 纳秒。
• $T_{\text{stacktrace}}$：fillInStackTrace 遍历栈帧，开销与栈深度成正比，约 1-10 微秒。
• $T_{\text{unwind}}$：栈展开，释放栈帧，开销与展开深度成正比。

HotSpot 的”零成本异常”优化：若异常在同一方法内抛出与捕获，且未填充栈轨迹（fillInStackTrace 返回 this），开销可降至 10-100 纳秒。因此异常不应用于正常控制流，仅用于真正的异常情形。

代码示例

示例 1：卫语句重构深层嵌套

/**
 * 卫语句重构示例
 * 演示如何将深层嵌套的 if-else 链重构为扁平的卫语句
 * 
 * 重构前：圈复杂度高，嵌套深，难以阅读
 * 重构后：每个前置条件独立检查，失败即返回，主逻辑扁平
 */
public class GuardClauseDemo {

    /**
     * 重构前：深层嵌套的传统写法
     * 圈复杂度 V(G) = 5，嵌套深度 3
     */
    public OrderResult processOrderNested(Order order) {
        if (order != null) {
            if (order.isValid()) {
                if (order.getAmount() <= MAX_AMOUNT) {
                    if (order.getCustomer().isActive()) {
                        // 主逻辑：处理订单
                        return executeOrder(order);
                    } else {
                        return OrderResult.fail("客户未激活");
                    }
                } else {
                    return OrderResult.fail("金额超限");
                }
            } else {
                return OrderResult.fail("订单无效");
            }
        } else {
            return OrderResult.fail("订单为空");
        }
    }

    /**
     * 重构后：使用卫语句扁平化
     * 圈复杂度 V(G) = 5（不变），但嵌套深度降为 1
     * 每个前置条件独立检查，失败立即返回
     * 主逻辑（executeOrder）位于方法末尾，一目了然
     */
    public OrderResult processOrderGuarded(Order order) {
        // 卫语句 1：空值检查
        if (order == null) {
            return OrderResult.fail("订单为空");
        }
        // 卫语句 2：有效性检查
        if (!order.isValid()) {
            return OrderResult.fail("订单无效");
        }
        // 卫语句 3：金额上限检查
        if (order.getAmount() > MAX_AMOUNT) {
            return OrderResult.fail("金额超限");
        }
        // 卫语句 4：客户状态检查
        if (!order.getCustomer().isActive()) {
            return OrderResult.fail("客户未激活");
        }
        // 主逻辑：所有前置条件满足，执行订单
        return executeOrder(order);
    }

    private static final double MAX_AMOUNT = 10000.0;

    private OrderResult executeOrder(Order order) {
        // 实际订单处理逻辑
        return OrderResult.success(order.getId());
    }
}

示例 2：switch 表达式与 yield

import java.time.DayOfWeek;

/**
 * switch 表达式示例（Java 14+）
 * 演示 switch 作为表达式返回值，以及 yield 处理复杂分支
 * 
 * 核心特性：
 * 1. 使用 -> 箭头语法，无需 break，无穿透
 * 2. 可直接作为表达式赋值
 * 3. yield 关键字在块中返回值
 * 4. 支持多个 case 标签合并
 */
public class SwitchExpressionDemo {

    /**
     * 简单 switch 表达式：直接返回值
     */
    public String getDayType(DayOfWeek day) {
        return switch (day) {
            case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "工作日";
            case SATURDAY, SUNDAY -> "周末";
        };
    }

    /**
     * 带 yield 的 switch 表达式：复杂分支逻辑
     * 当分支需要多行代码时，用块 + yield 返回值
     */
    public double calculateOvertimePay(DayOfWeek day, double hours, double baseRate) {
        return switch (day) {
            case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> {
                // 工作日加班：1.5 倍
                double pay = hours * baseRate * 1.5;
                yield pay;
            }
            case SATURDAY -> {
                // 周六加班：2.0 倍，且不足 4 小时按 4 小时计算
                double effectiveHours = Math.max(hours, 4.0);
                double pay = effectiveHours * baseRate * 2.0;
                yield pay;
            }
            case SUNDAY -> {
                // 周日加班：3.0 倍
                double pay = hours * baseRate * 3.0;
                yield pay;
            }
        };
    }

    /**
     * switch 表达式与枚举配合，穷尽性检查
     * 枚举的所有值都被覆盖，无需 default
     */
    public String getTrafficLightAction(TrafficLight light) {
        return switch (light) {
            case RED -> "停止";
            case YELLOW -> "准备停止";
            case GREEN -> "通行";
        };
    }

    public enum TrafficLight { RED, YELLOW, GREEN }
}

示例 3：switch 模式匹配（Java 21+）

/**
 * switch 模式匹配示例（Java 21+）
 * 演示类型模式、守卫子句、null 处理
 * 
 * 核心特性：
 * 1. case 类型 变量名 -> 绑定类型并自动转型
 * 2. case 类型 变量名 when 条件 -> 守卫子句细化分支
 * 3. case null -> 显式处理 null（不再抛 NPE）
 * 4. 配合密封类实现穷尽性检查
 */
public class SwitchPatternDemo {

    /**
     * 密封接口：限制实现类，配合 switch 穷尽性检查
     * 新增 Shape 子类时，编译器强制更新所有 switch
     */
    public sealed interface Shape
        permits Circle, Rectangle, Triangle {}

    public record Circle(double radius) implements Shape {}
    public record Rectangle(double width, double height) implements Shape {}
    public record Triangle(double a, double b, double c) implements Shape {}

    /**
     * 计算形状面积：类型模式 + 守卫子句
     */
    public double area(Shape shape) {
        return switch (shape) {
            case Circle c -> Math.PI * c.radius() * c.radius();
            case Rectangle r -> r.width() * r.height();
            case Triangle t when isRightTriangle(t) -> 0.5 * t.a() * t.b();
            case Triangle t -> heronFormula(t);
        };
    }

    /**
     * 处理可空输入：显式 case null
     */
    public String describe(Object obj) {
        return switch (obj) {
            case null -> "null 引用";
            case Integer i when i > 0 -> "正整数: " + i;
            case Integer i when i < 0 -> "负整数: " + i;
            case Integer i -> "零";
            case String s when s.length() > 100 -> "长字符串";
            case String s -> "短字符串: " + s;
            case int[] arr -> "整数数组，长度 " + arr.length;
            default -> "未知类型: " + obj.getClass().getSimpleName();
        };
    }

    private boolean isRightTriangle(Triangle t) {
        double a2 = t.a() * t.a();
        double b2 = t.b() * t.b();
        double c2 = t.c() * t.c();
        return Math.abs(a2 + b2 - c2) < 1e-9
            || Math.abs(a2 + c2 - b2) < 1e-9
            || Math.abs(b2 + c2 - a2) < 1e-9;
    }

    private double heronFormula(Triangle t) {
        double s = (t.a() + t.b() + t.c()) / 2;
        return Math.sqrt(s * (s - t.a()) * (s - t.b()) * (s - t.c()));
    }
}

示例 4：try-with-resources 管理多个资源

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

/**
 * try-with-resources 示例（Java 7+）
 * 演示自动资源管理，资源按声明逆序关闭
 * 
 * 核心特性：
 * 1. 资源必须实现 AutoCloseable
 * 2. 多个资源用分号分隔
 * 3. 关闭顺序与声明顺序相反（栈式）
 * 4. 关闭时抛出的异常用 addSuppressed 附加到主异常
 */
public class TryWithResourcesDemo {

    /**
     * 传统 try-finally：资源关闭代码冗长，易出错
     */
    public String readFileOldStyle(String path) throws IOException {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(path));
            return reader.readLine();
        } finally {
            // finally 中关闭资源：若 reader 构造失败则为 null
            // 若 close() 抛异常，会掩盖 try 块中的原始异常
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    // 通常只能记录日志，无法向上传递
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * try-with-resources：简洁且异常安全
     * 编译器自动生成 close() 调用与异常附加逻辑
     */
    public String readFileNewStyle(String path) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            return reader.readLine();
        }
    }

    /**
     * 管理多个资源：按声明逆序关闭
     * reader2 先关闭，reader1 后关闭（栈式关闭）
     */
    public void copyFile(String srcPath, String dstPath) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(srcPath));
             BufferedWriter writer = new BufferedWriter(new FileWriter(dstPath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        }
        // 离开 try 块时自动关闭：先 writer.close()，再 reader.close()
    }

    /**
     * 自定义 AutoCloseable 资源
     */
    public void useCustomResource() {
        try (DatabaseConnection conn = new DatabaseConnection("jdbc:postgresql://localhost/db");
             Transaction tx = conn.beginTransaction()) {
            conn.execute("UPDATE account SET balance = balance - 100 WHERE id = 1");
            conn.execute("UPDATE account SET balance = balance + 100 WHERE id = 2");
            // 离开 try 块时：先 tx.close()（提交或回滚），再 conn.close()
        }
    }

    /**
     * 自定义资源：实现 AutoCloseable
     */
    static class DatabaseConnection implements AutoCloseable {
        private final String url;
        private boolean closed = false;

        DatabaseConnection(String url) {
            this.url = url;
            System.out.println("打开连接: " + url);
        }

        Transaction beginTransaction() {
            return new Transaction(this);
        }

        void execute(String sql) {
            System.out.println("执行: " + sql);
        }

        @Override
        public void close() {
            if (!closed) {
                closed = true;
                System.out.println("关闭连接: " + url);
            }
        }
    }

    static class Transaction implements AutoCloseable {
        private final DatabaseConnection conn;
        private boolean committed = false;

        Transaction(DatabaseConnection conn) {
            this.conn = conn;
            System.out.println("开启事务");
        }

        void commit() {
            committed = true;
            System.out.println("提交事务");
        }

        @Override
        public void close() {
            if (!committed) {
                System.out.println("回滚事务（未显式提交）");
            }
        }
    }
}

示例 5：multi-catch 与异常链

/**
 * multi-catch 与异常链示例（Java 7+）
 * 演示多个异常类型合并捕获、异常链保留原始原因
 */
public class ExceptionChainingDemo {

    /**
     * multi-catch：多个异常类型用 | 分隔
     * 注意：catch 块中的变量是 final 的（不可重新赋值）
     */
    public void loadData(String source) throws DataLoadException {
        try {
            // 可能抛出多种异常
            processSource(source);
        } catch (IOException | SQLException e) {
            // multi-catch：统一处理
            // e 的编译时类型是 IOException 与 SQLException 的最近公共父类
            // e 是 final 的，不可重新赋值
            throw new DataLoadException("数据加载失败: " + source, e);
        }
    }

    /**
     * 异常链：保留原始异常作为 cause
     * 上层抛出业务异常，下层技术异常作为 cause 保留
     */
    public void transferMoney(long fromId, long toId, double amount)
            throws BusinessException {
        try {
            Account from = accountService.find(fromId);
            Account to = accountService.find(toId);
            from.debit(amount);
            to.credit(amount);
            accountService.save(from);
            accountService.save(to);
        } catch (SQLException e) {
            // 抛业务异常，保留原始异常作为 cause
            throw new BusinessException("数据库操作失败，转账未完成", e);
        } catch (InsufficientBalanceException e) {
            // 不需要链式：业务异常直接传播
            throw e;
        } catch (Exception e) {
            // 未知异常：包装为业务异常
            throw new BusinessException("转账失败: " + e.getMessage(), e);
        }
    }

    private void processSource(String source) throws IOException, SQLException {
        // 模拟处理
    }

    // 自定义异常
    public static class DataLoadException extends Exception {
        public DataLoadException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    public static class BusinessException extends Exception {
        public BusinessException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    public static class InsufficientBalanceException extends BusinessException {
        public InsufficientBalanceException(String msg) { super(msg, null); }
    }

    static class AccountService {
        Account find(long id) throws SQLException { return new Account(); }
        void save(Account a) throws SQLException {}
    }

    static class Account {
        void debit(double amount) throws InsufficientBalanceException {}
        void credit(double amount) {}
    }
}

示例 6：带标签的 break 跳出多层循环

/**
 * 带标签 break 示例
 * 演示从内层循环直接跳出多层
 * 
 * 使用场景：在矩阵中查找满足条件的元素，找到后立即停止所有循环
 * 替代方案：boolean 标志位（冗长）、异常控制流（反模式）
 */
public class LabeledBreakDemo {

    /**
     * 查找矩阵中第一个负数的位置
     * 使用带标签 break：找到即跳出双层循环
     */
    public Position findFirstNegative(int[][] matrix) {
        found:
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] < 0) {
                    // 找到负数，跳出外层循环
                    break found;
                }
            }
        }
        // 注意：break 后无法直接返回值，需用临时变量
        return searchResult(matrix);
    }

    /**
     * 更优雅的写法：将搜索逻辑提取到方法，用 return 代替 break
     */
    public Position findFirstNegativeRefactored(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] < 0) {
                    return new Position(i, j);
                }
            }
        }
        return null;
    }

    /**
     * 带标签 continue：跳过外层循环的当前迭代
     * 场景：处理二维数据，某行出现无效数据时跳过整行
     */
    public int processRows(int[][] data) {
        int processed = 0;
        nextRow:
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                if (data[i][j] < 0) {
                    // 当前行包含无效数据，跳过整行
                    System.out.println("跳过行 " + i + ": 包含负数");
                    continue nextRow;
                }
                // 处理单元格
                processCell(data[i][j]);
            }
            processed++;
        }
        return processed;
    }

    private Position searchResult(int[][] matrix) {
        // 实际搜索逻辑
        return null;
    }

    private void processCell(int value) {
        // 处理单元格
    }

    public record Position(int row, int col) {}
}

示例 7：assert 断言的使用

/**
 * assert 断言示例
 * 演示断言的正确用法与启用方式
 * 
 * 启用断言：java -ea MyClass（启用全部）
 *          java -ea:com.example... MyClass（启用指定包）
 *          java -da:com.example.foo MyClass（禁用指定类）
 * 
 * 重要原则：
 * 1. 断言用于校验内部不变量，不校验外部输入
 * 2. 断言失败意味着程序逻辑错误，不可恢复
 * 3. 断言不应有副作用（生产环境可能不启用）
 */
public class AssertionDemo {

    /**
     * 断言内部不变量：排序后的数组检查
     */
    public void sort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
        // 断言排序结果正确（内部不变量）
        assert isSorted(arr) : "排序后数组应为升序";
    }

    /**
     * 断言分支不可达：default 分支不应被触发
     */
    public String getColorCode(Color color) {
        return switch (color) {
            case RED -> "#FF0000";
            case GREEN -> "#00FF00";
            case BLUE -> "#0000FF";
        };
        // 编译器已知穷尽，无需 default
        // 若未来新增 Color 值而未更新 switch，编译失败
    }

    /**
     * 断言前置条件（私有方法）：私有方法可使用断言校验前置条件
     * 公有方法不应使用断言校验参数（公有方法的契约由参数校验保证）
     */
    private int binarySearch(int[] arr, int target, int low, int high) {
        // 私有方法：断言前置条件
        assert low >= 0 : "low 必须 >= 0";
        assert high < arr.length : "high 必须 < arr.length";
        assert low <= high : "low 必须 <= high";

        while (low <= high) {
            int mid = (low + high) >>> 1;
            if (arr[mid] < target) {
                low = mid + 1;
            } else if (arr[mid] > target) {
                high = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    /**
     * 断言后置条件：方法返回前的状态检查
     */
    public void withdraw(Account account, double amount) {
        double originalBalance = account.getBalance();
        assert amount > 0 && amount <= originalBalance : "取款金额非法";

        account.setBalance(originalBalance - amount);

        // 后置条件：余额不应为负
        assert account.getBalance() >= 0 : "余额不应为负";
    }

    private void quickSort(int[] arr, int low, int high) {}
    private boolean isSorted(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) return false;
        }
        return true;
    }

    enum Color { RED, GREEN, BLUE }

    static class Account {
        double getBalance() { return 0; }
        void setBalance(double b) {}
    }
}

示例 8：状态机模式与 switch 表达式

/**
 * 状态机模式示例
 * 演示使用 switch 表达式实现有限状态机（FSM）
 * 
 * 场景：订单状态流转
 * 状态：CREATED -> PAID -> SHIPPED -> DELIVERED -> CLOSED
 *       CREATED -> CANCELLED
 *       PAID -> CANCELLED（退款）
 */
public class OrderStateMachine {

    /**
     * 订单状态枚举
     */
    public enum OrderState {
        CREATED,    // 已创建
        PAID,       // 已支付
        SHIPPED,    // 已发货
        DELIVERED,  // 已签收
        CLOSED,     // 已关闭
        CANCELLED   // 已取消
    }

    /**
     * 订单事件枚举
     */
    public enum OrderEvent {
        PAY,        // 支付
        SHIP,       // 发货
        DELIVER,    // 签收
        CLOSE,      // 关闭
        CANCEL      // 取消
    }

    /**
     * 状态转移：switch 表达式实现状态机
     * 返回新状态，非法转移抛出异常
     */
    public OrderState transition(OrderState current, OrderEvent event) {
        return switch (current) {
            case CREATED -> switch (event) {
                case PAY -> OrderState.PAID;
                case CANCEL -> OrderState.CANCELLED;
                default -> throw new IllegalStateException(
                    "状态 CREATED 不支持事件 " + event);
            };
            case PAID -> switch (event) {
                case SHIP -> OrderState.SHIPPED;
                case CANCEL -> OrderState.CANCELLED;
                default -> throw new IllegalStateException(
                    "状态 PAID 不支持事件 " + event);
            };
            case SHIPPED -> switch (event) {
                case DELIVER -> OrderState.DELIVERED;
                default -> throw new IllegalStateException(
                    "状态 SHIPPED 不支持事件 " + event);
            };
            case DELIVERED -> switch (event) {
                case CLOSE -> OrderState.CLOSED;
                default -> throw new IllegalStateException(
                    "状态 DELIVERED 不支持事件 " + event);
            };
            case CLOSED, CANCELLED -> throw new IllegalStateException(
                "终态 " + current + " 不接受任何事件");
        };
    }

    /**
     * 安全的状态转移：返回结果而非抛异常
     */
    public TransitionResult safeTransition(OrderState current, OrderEvent event) {
        try {
            OrderState next = transition(current, event);
            return TransitionResult.success(next);
        } catch (IllegalStateException e) {
            return TransitionResult.failure(e.getMessage());
        }
    }

    public record TransitionResult(boolean success, OrderState newState, String error) {
        static TransitionResult success(OrderState state) {
            return new TransitionResult(true, state, null);
        }
        static TransitionResult failure(String error) {
            return new TransitionResult(false, null, error);
        }
    }
}

对比分析

if-else 链 vs switch 语句/表达式

try-with-resources vs 传统 try-finally

受检异常 vs 非受检异常

break vs return vs 异常控制流

常见陷阱

陷阱 1：switch 语句忘记 break 导致穿透

// 错误：传统 switch 忘记 break
switch (day) {
    case 1:
        System.out.println("Monday");
        // 忘记 break，会继续执行 case 2 的代码
    case 2:
        System.out.println("Tuesday");
        break;
}
// 当 day == 1 时，输出 "Monday" 和 "Tuesday"

// 正确：使用 switch 表达式（箭头语法）避免穿透
String name = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    default -> "Unknown";
};

陷阱 2：finally 块中 return 吞掉异常

// 错误：finally 中的 return 会吞掉 try 块的异常
public int badMethod() {
    try {
        throw new RuntimeException("业务异常");
    } finally {
        return 1;  // 异常被吞，调用方无法感知
    }
}

// 正确：finally 中不要 return，只做清理
public int goodMethod() {
    try {
        doWork();
        return computeResult();
    } finally {
        cleanup();  // 只做清理，不 return
    }
}

陷阱 3：浮点数相等比较

// 错误：浮点数直接比较
if (0.1 + 0.2 == 0.3) {
    // 永远不会执行，0.1 + 0.2 = 0.30000000000000004
}

// 正确：使用容差比较
if (Math.abs(0.1 + 0.2 - 0.3) < 1e-9) {
    // 正确执行
}

// 或使用 BigDecimal
import java.math.BigDecimal;
if (new BigDecimal("0.1").add(new BigDecimal("0.2"))
        .compareTo(new BigDecimal("0.3")) == 0) {
    // 正确执行
}

陷阱 4：== 比较包装类实例

// 错误：Integer 缓存范围外用 == 比较
Integer a = 200;
Integer b = 200;
if (a == b) {
    // false，因为 200 超出 Integer 缓存范围 [-128, 127]
}

// 正确：用 equals 比较
if (a.equals(b)) {
    // true
}

陷阱 5：for-each 中修改集合

// 错误：for-each 遍历时修改集合，抛 ConcurrentModificationException
for (String item : list) {
    if (item.isEmpty()) {
        list.remove(item);  // CME
    }
}

// 正确方案 1：使用 Iterator.remove()
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().isEmpty()) {
        it.remove();  // 安全
    }
}

// 正确方案 2：Java 8+ removeIf
list.removeIf(String::isEmpty);

陷阱 6：异常被空 catch 吞掉

// 错误：空 catch 块吞掉异常，问题被隐藏
try {
    riskyOperation();
} catch (Exception e) {
    // 什么都不做，问题被掩盖
}

// 正确：至少记录日志或包装后重新抛出
try {
    riskyOperation();
} catch (Exception e) {
    logger.error("操作失败", e);
    throw new BusinessException("操作失败", e);
}

陷阱 7：catch 顺序错误（子类在父类之后）

// 错误：子类异常在父类之后，编译失败
try {
    // ...
} catch (Exception e) {
    // 捕获所有异常
} catch (IOException e) {
    // 编译错误：IOException 永远不可达
}

// 正确：子类在前，父类在后
try {
    // ...
} catch (IOException e) {
    // 先处理具体异常
} catch (Exception e) {
    // 再处理通用异常
}

陷阱 8：assert 用于参数校验

// 错误：assert 用于公有方法参数校验
public void process(Order order) {
    assert order != null : "订单不能为空";  // 生产环境默认禁用，无效
    // ...
}

// 正确：公有方法用显式校验 + 抛异常
public void process(Order order) {
    if (order == null) {
        throw new IllegalArgumentException("订单不能为空");
    }
    // ...
}

陷阱 9：循环中创建对象

// 错误：每次循环创建新对象
for (int i = 0; i < 1000; i++) {
    SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
    // 使用 fmt
}

// 正确：将不可变对象提到循环外
SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < 1000; i++) {
    // 使用 fmt
}

// 更优：使用线程安全的 DateTimeFormatter
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");

陷阱 10：在 for-each 中获取索引

// 错误：for-each 无法直接获取索引
int i = 0;
for (String item : list) {
    System.out.println(i + ": " + item);
    i++;
}

// 更优雅：使用普通 for 循环
for (int i = 0; i < list.size(); i++) {
    System.out.println(i + ": " + list.get(i));
}

// 或使用 IntStream（Java 8+）
IntStream.range(0, list.size())
    .forEach(i -> System.out.println(i + ": " + list.get(i)));

工程实践

实践 1：圈复杂度控制

控制单个方法的圈复杂度不超过 10，可通过以下手段：

/**
 * 圈复杂度控制：拆分大方法为小方法
 */
public class ComplexityControl {

    /**
     * 重构前：高复杂度方法（V(G) = 8）
     */
    public double calculatePrice(Order order) {
        double price = 0;
        if (order.getType() == OrderType.NORMAL) {
            if (order.getCustomer().isVip()) {
                price = order.getAmount() * 0.9;
            } else {
                price = order.getAmount();
            }
        } else if (order.getType() == OrderType.PROMOTION) {
            if (order.getAmount() > 1000) {
                price = order.getAmount() * 0.8;
            } else {
                price = order.getAmount() * 0.85;
            }
        } else if (order.getType() == OrderType.WHOLESALE) {
            if (order.getQuantity() > 100) {
                price = order.getAmount() * 0.7;
            } else {
                price = order.getAmount() * 0.75;
            }
        }
        return price;
    }

    /**
     * 重构后：使用策略模式 + switch 表达式，复杂度降至 2
     */
    public double calculatePriceRefactored(Order order) {
        return PriceStrategy.of(order.getType()).calculate(order);
    }

    interface PriceStrategy {
        double calculate(Order order);

        static PriceStrategy of(OrderType type) {
            return switch (type) {
                case NORMAL -> new NormalStrategy();
                case PROMOTION -> new PromotionStrategy();
                case WHOLESALE -> new WholesaleStrategy();
            };
        }
    }

    static class NormalStrategy implements PriceStrategy {
        public double calculate(Order order) {
            return order.getCustomer().isVip()
                ? order.getAmount() * 0.9
                : order.getAmount();
        }
    }

    static class PromotionStrategy implements PriceStrategy {
        public double calculate(Order order) {
            return order.getAmount() > 1000
                ? order.getAmount() * 0.8
                : order.getAmount() * 0.85;
        }
    }

    static class WholesaleStrategy implements PriceStrategy {
        public double calculate(Order order) {
            return order.getQuantity() > 100
                ? order.getAmount() * 0.7
                : order.getAmount() * 0.75;
        }
    }

    enum OrderType { NORMAL, PROMOTION, WHOLESALE }
    static class Order {
        OrderType getType() { return OrderType.NORMAL; }
        double getAmount() { return 0; }
        int getQuantity() { return 0; }
        Customer getCustomer() { return new Customer(); }
    }
    static class Customer { boolean isVip() { return false; } }
}

实践 2：异常层次设计

/**
 * 异常层次设计：业务异常根 + 具体异常
 */
public class ExceptionHierarchy {

    /** 业务异常根（非受检） */
    public static class BusinessException extends RuntimeException {
        private final String errorCode;

        public BusinessException(String errorCode, String message) {
            super(message);
            this.errorCode = errorCode;
        }

        public BusinessException(String errorCode, String message, Throwable cause) {
            super(message, cause);
            this.errorCode = errorCode;
        }

        public String getErrorCode() { return errorCode; }
    }

    /** 用户相关异常 */
    public static class UserException extends BusinessException {
        public UserException(String code, String msg) { super(code, msg); }
    }

    /** 订单相关异常 */
    public static class OrderException extends BusinessException {
        public OrderException(String code, String msg) { super(code, msg); }
    }

    /** 支付相关异常 */
    public static class PaymentException extends BusinessException {
        public PaymentException(String code, String msg, Throwable cause) {
            super(code, msg, cause);
        }
    }

    /**
     * 统一异常处理：捕获根异常，提取错误码
     */
    public void handle(Exception e) {
        if (e instanceof BusinessException be) {
            log.error("业务异常: code={}, msg={}", be.getErrorCode(), be.getMessage());
            respondError(be.getErrorCode(), be.getMessage());
        } else {
            log.error("系统异常", e);
            respondError("SYSTEM_ERROR", "系统繁忙");
        }
    }

    private void log(Object... args) {}
    private void respondError(String code, String msg) {}
}

实践 3：循环性能优化

/**
 * 循环性能优化技巧
 */
public class LoopOptimization {

    /**
     * 优化 1：循环不变量外提
     */
    public int[] badLoop(int[] arr, int multiplier) {
        for (int i = 0; i < arr.length; i++) {
            // list.size() 每次循环都调用
            arr[i] = arr[i] * multiplier + computeOffset();
        }
        return arr;
    }

    public int[] goodLoop(int[] arr, int multiplier) {
        int offset = computeOffset();  // 外提不变量
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * multiplier + offset;
        }
        return arr;
    }

    /**
     * 优化 2：字符串拼接用 StringBuilder
     */
    public String badConcat(String[] items) {
        String result = "";
        for (String item : items) {
            result += item + ", ";  // 每次创建新 String
        }
        return result;
    }

    public String goodConcat(String[] items) {
        StringBuilder sb = new StringBuilder(items.length * 16);
        for (int i = 0; i < items.length; i++) {
            if (i > 0) sb.append(", ");
            sb.append(items[i]);
        }
        return sb.toString();
    }

    /**
     * 优化 3：避免在循环中调用同步方法
     */
    public void badSync(List<String> keys) {
        for (String key : keys) {
            synchronized (cache) {  // 每次循环都加锁
                cache.put(key, loadFromDb(key));
            }
        }
    }

    public void goodSync(List<String> keys) {
        Map<String, String> batch = new HashMap<>();
        for (String key : keys) {
            batch.put(key, loadFromDb(key));
        }
        synchronized (cache) {  // 批量加锁
            cache.putAll(batch);
        }
    }

    private int computeOffset() { return 0; }
    private String loadFromDb(String key) { return ""; }

    private final Map<String, String> cache = new HashMap<>();
}

实践 4：防御性编程

import java.util.Objects;

/**
 * 防御性编程：参数校验、不可变返回、空值处理
 */
public class DefensiveProgramming {

    /**
     * 参数校验：fail-fast
     */
    public void transfer(Account from, Account to, double amount) {
        // 校验非空
        Objects.requireNonNull(from, "转出账户不能为空");
        Objects.requireNonNull(to, "转入账户不能为空");
        // 校验业务规则
        if (amount <= 0) {
            throw new IllegalArgumentException("转账金额必须为正: " + amount);
        }
        if (from.equals(to)) {
            throw new IllegalArgumentException("转出与转入账户不能相同");
        }
        if (from.getBalance() < amount) {
            throw new InsufficientBalanceException(
                "余额不足: 余额=" + from.getBalance() + ", 转账=" + amount);
        }
        // 执行业务
        from.debit(amount);
        to.credit(amount);
    }

    /**
     * 不可变返回：防止外部修改内部状态
     */
    public List<Order> getOrders() {
        // 返回不可修改的视图
        return Collections.unmodifiableList(orders);
    }

    /**
     * 防御性拷贝：防止外部通过引用修改内部对象
     */
    public Date getCreatedAt() {
        // 返回拷贝，外部修改不影响内部
        return new Date(createdAt.getTime());
    }

    private final List<Order> orders = new ArrayList<>();
    private final Date createdAt = new Date();

    static class Account {
        double getBalance() { return 0; }
        void debit(double amount) {}
        void credit(double amount) {}
        public boolean equals(Account other) { return this == other; }
    }

    static class Order {}
    static class InsufficientBalanceException extends RuntimeException {
        InsufficientBalanceException(String msg) { super(msg); }
    }
}

实践 5：使用 Optional 替代 null 检查

import java.util.Optional;

/**
 * Optional 替代 null 检查
 * 显式表达"可能不存在"的语义
 */
public class OptionalPattern {

    /**
     * 传统 null 检查：易漏、易 NPE
     */
    public String getCityOld(User user) {
        if (user != null) {
            Address addr = user.getAddress();
            if (addr != null) {
                return addr.getCity();
            }
        }
        return "Unknown";
    }

    /**
     * Optional 链式调用：类型安全
     */
    public String getCityNew(Optional<User> userOpt) {
        return userOpt
            .map(User::getAddress)
            .map(Address::getCity)
            .orElse("Unknown");
    }

    /**
     * Optional.orElseThrow：明确不存在时抛异常
     */
    public User findUser(Long id) {
        return Optional.ofNullable(userDb.get(id))
            .orElseThrow(() -> new UserNotFoundException("用户不存在: " + id));
    }

    /**
     * Optional.ifPresent：存在时才执行
     */
    public void notifyUser(Long userId) {
        Optional.ofNullable(userDb.get(userId))
            .ifPresent(user -> emailService.send(user.getEmail(), "通知"));
    }

    private final java.util.Map<Long, User> userDb = new java.util.HashMap<>();
    static class User { Address getAddress() { return null; } String getEmail() { return ""; } }
    static class Address { String getCity() { return ""; } }
    static class UserNotFoundException extends RuntimeException {
        UserNotFoundException(String msg) { super(msg); }
    }
    static class EmailService { void send(String to, String body) {} }
}

实践 6：结构化并发与控制流（Java 21+）

import java.util.concurrent.StructuredTaskScope;

/**
 * 结构化并发示例（Java 21+）
 * 演示使用 StructuredTaskScope 管理并发任务的生命周期
 * 
 * 核心思想：子任务的生命周期与结构化块绑定
 * 离开 try-with-resources 时，所有未完成子任务被取消
 */
public class StructuredConcurrencyDemo {

    /**
     * 并行获取用户与订单，任一失败则取消另一个
     */
    public record UserProfile(User user, Order order) {}

    public UserProfile loadProfile(Long userId) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 并行分支
            StructuredTaskScope.Subtask<User> userTask =
                scope.fork(() -> userService.findUser(userId));
            StructuredTaskScope.Subtask<Order> orderTask =
                scope.fork(() -> orderService.findLatestOrder(userId));

            // 等待所有分支完成
            scope.join();
            // 若任一分支失败，抛异常
            scope.throwIfFailed();

            return new UserProfile(userTask.get(), orderTask.get());
        }
    }

    /**
     * 第一个成功即返回（如多源查询）
     */
    public String queryFirstAvailable(String query) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
            scope.fork(() -> searchEngine1.query(query));
            scope.fork(() -> searchEngine2.query(query));
            scope.fork(() -> searchEngine3.query(query));
            scope.join();
            return scope.result();
        }
    }

    static class UserService { User findUser(Long id) { return new User(); } }
    static class OrderService { Order findLatestOrder(Long id) { return new Order(); } }
    static class SearchEngine {
        String query(String q) { return "result"; }
    }
    static class User {}
    static class Order {}
    private final UserService userService = new UserService();
    private final OrderService orderService = new OrderService();
    private final SearchEngine searchEngine1 = new SearchEngine();
    private final SearchEngine searchEngine2 = new SearchEngine();
    private final SearchEngine searchEngine3 = new SearchEngine();
}

案例研究

案例 1：电商订单状态流转系统

场景：某电商平台需实现订单状态机，支持多种状态与事件组合，要求类型安全、易于扩展。

问题：传统 if-else 链实现的状态机难以维护，新增状态或事件需修改多处代码。

解决方案：使用枚举 + switch 表达式 + 密封接口。

/**
 * 订单状态机：枚举驱动 + switch 表达式
 * 
 * 设计要点：
 * 1. 状态与事件用枚举，编译期类型安全
 * 2. switch 表达式穷尽性检查，新增状态时强制更新
 * 3. 转移规则集中管理，单一事实来源
 * 4. 非法转移返回错误而非抛异常，便于业务处理
 */
public class OrderStateMachineCase {

    public enum State {
        CREATED, PAID, SHIPPED, DELIVERED, CLOSED, CANCELLED, REFUNDED
    }

    public enum Event {
        PAY, SHIP, DELIVER, CLOSE, CANCEL, REFUND
    }

    public sealed interface Transition permits Valid, Invalid {}
    public record Valid(State next) implements Transition {}
    public record Invalid(String reason) implements Transition {}

    /**
     * 状态转移表：使用 switch 表达式实现
     * 穷尽性保证：新增 State 时编译器强制更新
     */
    public Transition apply(State current, Event event) {
        return switch (current) {
            case CREATED -> switch (event) {
                case PAY -> new Valid(State.PAID);
                case CANCEL -> new Valid(State.CANCELLED);
                default -> new Invalid("CREATED 状态仅支持 PAY/CANCEL");
            };
            case PAID -> switch (event) {
                case SHIP -> new Valid(State.SHIPPED);
                case CANCEL -> new Valid(State.REFUNDED);
                case REFUND -> new Valid(State.REFUNDED);
                default -> new Invalid("PAID 状态仅支持 SHIP/CANCEL/REFUND");
            };
            case SHIPPED -> switch (event) {
                case DELIVER -> new Valid(State.DELIVERED);
                default -> new Invalid("SHIPPED 状态仅支持 DELIVER");
            };
            case DELIVERED -> switch (event) {
                case CLOSE -> new Valid(State.CLOSED);
                case REFUND -> new Valid(State.REFUNDED);
                default -> new Invalid("DELIVERED 状态仅支持 CLOSE/REFUND");
            };
            case CLOSED, CANCELLED, REFUNDED ->
                new Invalid("终态 " + current + " 不接受任何事件");
        };
    }

    /**
     * 业务调用：状态转移 + 副作用执行
     */
    public StateResult transition(Order order, Event event) {
        Transition t = apply(order.getState(), event);
        if (t instanceof Valid v) {
            // 执行副作用：持久化、通知等
            order.setState(v.next());
            eventBus.publish(new StateChangedEvent(order.getId(), v.next()));
            return StateResult.success(v.next());
        } else if (t instanceof Invalid inv) {
            return StateResult.failure(inv.reason());
        }
        throw new IllegalStateException("不可达");
    }

    public record StateResult(boolean success, State state, String error) {
        static StateResult success(State s) { return new StateResult(true, s, null); }
        static StateResult failure(String e) { return new StateResult(false, null, e); }
    }

    // 支撑类
    static class Order {
        private State state;
        public State getState() { return state; }
        public void setState(State s) { this.state = s; }
        public Long getId() { return 0L; }
    }
    static class EventBus { void publish(Object e) {} }
    static class StateChangedEvent {
        StateChangedEvent(Long id, State s) {}
    }
    private final EventBus eventBus = new EventBus();
}

案例 2：配置解析器异常处理

场景：解析 YAML 配置文件，需处理多种异常情形（文件不存在、格式错误、类型不匹配）。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;

/**
 * 配置解析器：分层异常处理
 * 
 * 设计要点：
 * 1. 区分可恢复与不可恢复异常
 * 2. 保留原始异常作为 cause
 * 3. 提供友好的错误信息（包含文件路径、行号）
 */
public class ConfigParserCase {

    /**
     * 解析配置：多级异常处理
     */
    public AppConfig parse(Path configPath) throws ConfigException {
        // 第一层：文件读取
        String content;
        try {
            content = Files.readString(configPath);
        } catch (IOException e) {
            throw new ConfigException(
                "配置文件读取失败: " + configPath, e);
        }

        // 第二层：YAML 解析
        Map<String, Object> raw;
        try {
            raw = yamlParser.parse(content);
        } catch (YamlParseException e) {
            throw new ConfigException(
                "YAML 格式错误，行 " + e.getLine() + ": " + e.getMessage(), e);
        }

        // 第三层：字段映射
        try {
            return mapToConfig(raw);
        } catch (TypeMismatchException e) {
            throw new ConfigException(
                "配置字段类型不匹配: " + e.getField() + ", 期望 " + e.getExpected(), e);
        } catch (MissingFieldException e) {
            throw new ConfigException(
                "缺少必填字段: " + e.getField(), e);
        }
    }

    /**
     * 带默认值的解析：失败时返回默认配置
     */
    public AppConfig parseOrDefault(Path configPath, AppConfig defaultValue) {
        try {
            return parse(configPath);
        } catch (ConfigException e) {
            logger.warn("配置解析失败，使用默认配置: {}", e.getMessage());
            return defaultValue;
        }
    }

    private AppConfig mapToConfig(Map<String, Object> raw) {
        return new AppConfig();
    }

    // 自定义异常
    public static class ConfigException extends Exception {
        public ConfigException(String msg, Throwable cause) { super(msg, cause); }
    }
    public static class YamlParseException extends RuntimeException {
        private final int line;
        public YamlParseException(int line, String msg) { super(msg); this.line = line; }
        public int getLine() { return line; }
    }
    public static class TypeMismatchException extends RuntimeException {
        private final String field;
        private final String expected;
        public TypeMismatchException(String f, String e) { field = f; expected = e; }
        public String getField() { return field; }
        public String getExpected() { return expected; }
    }
    public static class MissingFieldException extends RuntimeException {
        private final String field;
        public MissingFieldException(String f) { field = f; }
        public String getField() { return field; }
    }

    static class AppConfig {}
    static class YamlParser {
        Map<String, Object> parse(String content) { return Map.of(); }
    }
    private final YamlParser yamlParser = new YamlParser();
    private static final org.slf4j.Logger logger = null;
}

案例 3：批处理任务的异常隔离

场景：批量处理 10 万条订单数据，单条失败不应影响整体，但需记录失败明细。

import java.util.*;

/**
 * 批处理异常隔离：部分失败不阻塞整体
 */
public class BatchProcessorCase {

    /**
     * 批处理：单条失败不影响整体
     */
    public BatchResult processBatch(List<Order> orders) {
        List<ProcessResult> success = new ArrayList<>();
        List<ProcessFailure> failures = new ArrayList<>();

        for (Order order : orders) {
            try {
                ProcessResult result = processSingle(order);
                success.add(result);
            } catch (ValidationException e) {
                // 业务校验失败：记录并继续
                failures.add(new ProcessFailure(order.getId(), e.getMessage(), e));
            } catch (TemporaryFailureException e) {
                // 临时失败：重试或记录
                failures.add(new ProcessFailure(order.getId(), "临时失败: " + e.getMessage(), e));
            } catch (Exception e) {
                // 未知异常：记录并继续，避免整体崩溃
                failures.add(new ProcessFailure(order.getId(), "未知异常: " + e.getMessage(), e));
                logger.error("处理订单 {} 时未知异常", order.getId(), e);
            }
        }

        return new BatchResult(success, failures);
    }

    /**
     * 失败重试：可配置的重试策略
     */
    public ProcessResult processWithRetry(Order order, int maxAttempts) {
        Exception lastException = null;
        for (int attempt = 1; attempt <= maxAttempts; attempt++) {
            try {
                return processSingle(order);
            } catch (TemporaryFailureException e) {
                lastException = e;
                // 指数退避
                sleep(Math.pow(2, attempt) * 100);
            } catch (ValidationException | PermanentFailureException e) {
                // 不可重试的异常：立即失败
                throw e;
            }
        }
        throw new PermanentFailureException(
            "重试 " + maxAttempts + " 次后仍失败: " + lastException.getMessage(),
            lastException);
    }

    private ProcessResult processSingle(Order order) {
        return new ProcessResult();
    }
    private void sleep(double millis) {}

    // 结果与异常类型
    public record BatchResult(List<ProcessResult> success, List<ProcessFailure> failures) {
        public int totalCount() { return success.size() + failures.size(); }
        public double successRate() {
            return totalCount() == 0 ? 0 : (double) success.size() / totalCount();
        }
    }
    public record ProcessResult() {}
    public record ProcessFailure(String orderId, String error, Exception cause) {}
    static class Order { String getId() { return ""; } }
    static class ValidationException extends RuntimeException {
        ValidationException(String msg) { super(msg); }
    }
    static class TemporaryFailureException extends RuntimeException {
        TemporaryFailureException(String msg) { super(msg); }
    }
    static class PermanentFailureException extends RuntimeException {
        PermanentFailureException(String msg, Throwable cause) { super(msg, cause); }
    }
    private static final org.slf4j.Logger logger = null;
}

案例 4：规则引擎的 switch 模式匹配实现

场景：实现一个简单的规则引擎，根据不同事件类型触发不同处理逻辑。

/**
 * 规则引擎：基于 switch 模式匹配
 * 演示 Java 21 模式匹配在业务场景的应用
 */
public class RuleEngineCase {

    /** 事件密封接口：限制事件类型 */
    public sealed interface Event permits LoginEvent, LogoutEvent, PurchaseEvent, RefundEvent {}

    public record LoginEvent(String userId, String ip, long timestamp) implements Event {}
    public record LogoutEvent(String userId, long timestamp) implements Event {}
    public record PurchaseEvent(String userId, String orderId, double amount) implements Event {}
    public record RefundEvent(String orderId, double amount, String reason) implements Event {}

    /** 规则执行结果 */
    public record RuleResult(boolean triggered, String ruleName, String action) {}

    /**
     * 规则匹配：switch 模式匹配 + 守卫子句
     */
    public List<RuleResult> evaluate(Event event) {
        List<RuleResult> results = new ArrayList<>();

        // 风控规则：异地登录
        if (event instanceof LoginEvent le
                && isRemoteIp(le.ip())
                && !isUserKnownIp(le.userId(), le.ip())) {
            results.add(new RuleResult(true, "REMOTE_LOGIN",
                "要求二次验证"));
        }

        // 风控规则：大额消费
        if (event instanceof PurchaseEvent pe && pe.amount() > 10000) {
            results.add(new RuleResult(true, "LARGE_PURCHASE",
                "触发人工审核"));
        }

        // 风控规则：高频退款
        if (event instanceof RefundEvent re
                && refundCountLast24h() > 5) {
            results.add(new RuleResult(true, "FREQUENT_REFUND",
                "冻结账户 24 小时"));
        }

        // 使用 switch 模式匹配处理事件分发
        switch (event) {
            case LoginEvent le -> auditLog("登录", le.userId(), le.ip());
            case LogoutEvent le -> auditLog("登出", le.userId(), null);
            case PurchaseEvent pe -> auditLog("消费", pe.userId(), "金额 " + pe.amount());
            case RefundEvent re -> auditLog("退款", null, "订单 " + re.orderId());
        }

        return results;
    }

    private boolean isRemoteIp(String ip) { return false; }
    private boolean isUserKnownIp(String userId, String ip) { return true; }
    private int refundCountLast24h() { return 0; }
    private void auditLog(String type, String userId, String detail) {}

    private static final org.slf4j.Logger logger = null;
}