异常处理

// Throwable 的核心构造器签名
public class Throwable {
    // 无参构造：message 为 null，cause 为 null
    public Throwable() {}
 
    // 传入描述信息
    public Throwable(String message) {}
 
    // 传入描述信息 + 根因异常（异常链）
    public Throwable(String message, Throwable cause) {}
 
    // 仅传入根因异常，message 自动取 cause.toString()
    public Throwable(Throwable cause) {}
}

// 一个经典的 StackOverflowError 示例
public class ErrorDemo {
    // 这个方法无限递归调用自身
    public static void infiniteRecursion() {
        // 每次调用都会在栈上压入新的栈帧，永远不会返回
        infiniteRecursion(); // 没有终止条件 → StackOverflowError
    }
 
    public static void main(String[] args) {
        // 调用后很快就会栈溢出
        infiniteRecursion();
        // 输出类似：Exception in thread "main" java.lang.StackOverflowError
    }
}

public class RuntimeExceptionDemo {
    public static void main(String[] args) {
        // 1. NullPointerException —— 对 null 调用方法
        String str = null;       // str 指向 null，不指向任何对象
        // str.length();         // 取消注释会抛出 NPE
 
        // 2. ArrayIndexOutOfBoundsException —— 下标越界
        int[] arr = {1, 2, 3};   // 数组长度为 3，合法下标为 0, 1, 2
        // int val = arr[5];     // 下标 5 超出范围，抛出越界异常
 
        // 3. ClassCastException —— 非法类型转换
        Object obj = "Hello";    // obj 实际指向一个 String 对象
        // Integer num = (Integer) obj; // String 不能转为 Integer，抛出 CCE
 
        // 4. ArithmeticException —— 整数除零
        // int result = 10 / 0;  // 整数除以 0，抛出算术异常
        // 注意：浮点数除零不会抛异常，而是得到 Infinity 或 NaN
        double floatResult = 10.0 / 0; // 结果为 Infinity，不抛异常
        System.out.println(floatResult); // 输出: Infinity
    }
}

public class ExceptionInspector {
    public static void main(String[] args) {
        // 创建几个不同类型的异常实例
        Throwable npe = new NullPointerException("空指针");       // RuntimeException 子类
        Throwable ioe = new java.io.IOException("IO错误");        // Checked Exception
        Throwable oom = new OutOfMemoryError("内存不足");          // Error 子类
 
        // 用 instanceof 判断异常所属分支
        System.out.println("NPE 是 RuntimeException? " 
            + (npe instanceof RuntimeException));  // true
        System.out.println("NPE 是 Exception? " 
            + (npe instanceof Exception));          // true（RuntimeException 继承自 Exception）
        System.out.println("NPE 是 Error? " 
            + (npe instanceof Error));              // false
 
        System.out.println("IOException 是 RuntimeException? " 
            + (ioe instanceof RuntimeException));  // false（它是 Checked Exception）
        System.out.println("IOException 是 Exception? " 
            + (ioe instanceof Exception));          // true
 
        System.out.println("OOM 是 Error? " 
            + (oom instanceof Error));              // true
        System.out.println("OOM 是 Exception? " 
            + (oom instanceof Exception));          // false（Error 和 Exception 是平级的）
    }
}

public class CatchScopeDemo {
    public static void main(String[] args) {
        try {
            // 手动抛出一个 Error
            throw new StackOverflowError("模拟栈溢出");
        } catch (Exception e) {
            // 这个 catch 块捕获不到 Error
            System.out.println("Exception caught: " + e.getMessage());
        } catch (Error err) {
            // Error 会被这个块捕获（仅作演示，实际不建议这样做）
            System.out.println("Error caught: " + err.getMessage());
            // 输出: Error caught: 模拟栈溢出
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
public class CheckedDemo {
    public static void main(String[] args) {
        // FileReader 构造器声明抛出 FileNotFoundException（Checked）
        // BufferedReader.readLine() 声明抛出 IOException（Checked）
        // 如果不处理，编译器直接报错：Unhandled exception: java.io.IOException
        try {
            FileReader fr = new FileReader("data.txt");       // 可能文件不存在
            BufferedReader br = new BufferedReader(fr);        // 包装为缓冲读取器
            String line = br.readLine();                       // 可能读取失败
            System.out.println(line);                          // 正常输出第一行
            br.close();                                        // 关闭资源
        } catch (IOException e) {
            // 编译器强制要求你处理这个异常
            System.err.println("文件读取失败: " + e.getMessage());
        }
    }
}

public class UncheckedDemo {
    public static void main(String[] args) {
        // 以下代码全部能通过编译，编译器不会有任何警告
        // 但运行时会抛出异常
 
        String s = null;
        // s.length();  // 运行时抛出 NullPointerException
 
        int[] arr = {1, 2, 3};
        // arr[5] = 10;  // 运行时抛出 ArrayIndexOutOfBoundsException
 
        // 整数除以零，运行时抛出 ArithmeticException
        // int result = 10 / 0;
 
        // 正确的做法：通过防御性编程避免异常，而不是 try-catch
        if (s != null) {                          // 先判空再调用
            System.out.println(s.length());
        }
 
        int index = 5;
        if (index >= 0 && index < arr.length) {   // 先检查边界再访问
            System.out.println(arr[index]);
        }
 
        int divisor = 0;
        if (divisor != 0) {                       // 先检查除数再运算
            System.out.println(10 / divisor);
        }
    }
}

public class ComparisonDemo {
 
    // ========== Checked Exception 示例 ==========
    // 方法签名必须用 throws 声明，否则编译失败
    public static String readConfig(String path) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(path)); // 可能文件不存在
        String content = reader.readLine();                              // 可能读取失败
        reader.close();                                                  // 关闭资源
        return content;                                                  // 返回读取内容
    }
 
    // ========== Unchecked Exception 示例 ==========
    // 方法签名不需要声明任何异常，编译器不关心
    public static int divide(int a, int b) {
        if (b == 0) {
            // 主动抛出 Unchecked Exception，提示调用者传参有误
            throw new IllegalArgumentException("除数不能为零 (divisor must not be zero)");
        }
        return a / b;  // 安全执行除法
    }
 
    public static void main(String[] args) {
        // 调用 readConfig 时，编译器强制你处理 IOException
        try {
            String config = readConfig("/etc/app.conf");
            System.out.println("配置内容: " + config);
        } catch (IOException e) {
            System.err.println("读取配置失败，使用默认值: " + e.getMessage());
            // 可恢复：降级为默认配置
        }
 
        // 调用 divide 时，编译器不强制你处理
        // 但良好的实践是在调用前做参数校验
        int divisor = 0;
        if (divisor != 0) {
            System.out.println(divide(10, divisor));
        } else {
            System.out.println("跳过除法：除数为零");
        }
    }
}

// 反面教材：为了通过编译而写的空 catch，吞掉了异常信息
// 这比不处理还糟糕，因为问题被彻底隐藏了
try {
    riskyOperation();
} catch (IOException e) {
    // TODO: handle later  ← 这个 "later" 永远不会到来
}

public class DataAccessException extends RuntimeException {
    // 继承 RuntimeException，成为 Unchecked
    public DataAccessException(String message, Throwable cause) {
        super(message, cause);  // 保留原始异常链
    }
}
 
public class UserRepository {
    public User findById(long id) {
        try {
            // JDBC 操作，抛出 Checked 的 SQLException
            return queryFromDatabase(id);
        } catch (SQLException e) {
            // 转换为 Unchecked，调用者不需要被迫处理
            throw new DataAccessException("查询用户失败, id=" + id, e);
        }
    }
}

// ===== 自定义 Unchecked 异常：业务规则校验失败 =====
public class InvalidUserException extends RuntimeException {
    private final String field;  // 记录哪个字段出了问题
 
    public InvalidUserException(String field, String message) {
        super(message);          // 传递错误信息给父类
        this.field = field;      // 保存字段名
    }
 
    public String getField() {
        return field;            // 提供字段名的访问器
    }
}
 
// ===== Service 层 =====
public class UserService {
 
    private final UserRepository repo;
 
    public UserService(UserRepository repo) {
        this.repo = repo;        // 依赖注入 Repository
    }
 
    public void register(String username, String email) {
        // 参数校验 → 抛 Unchecked（这是编程错误 / 非法输入）
        if (username == null || username.isBlank()) {
            throw new InvalidUserException("username", "用户名不能为空");
        }
        if (email == null || !email.contains("@")) {
            throw new InvalidUserException("email", "邮箱格式不合法");
        }
 
        // 持久化 → repo 内部已将 Checked 转为 Unchecked
        // 调用者无需被迫写 try-catch
        repo.save(new User(username, email));
    }
}
 
// ===== Controller 层统一处理 =====
public class UserController {
    private final UserService service;
 
    public void handleRegister(String username, String email) {
        try {
            service.register(username, email);           // 调用业务逻辑
            System.out.println("注册成功");
        } catch (InvalidUserException e) {
            // 业务异常：返回友好提示
            System.err.println("参数错误 [" + e.getField() + "]: " + e.getMessage());
        } catch (DataAccessException e) {
            // 基础设施异常：记录日志，返回通用错误
            System.err.println("系统繁忙，请稍后重试");
            // logger.error("数据库异常", e);  // 实际项目中记录完整堆栈
        }
    }
}

public class Quiz {
    public static void main(String[] args) {
        Thread.sleep(1000);
        System.out.println("done");
    }
}

try {
    // 可能抛出异常的代码（risky code）
} catch (ExceptionType1 e1) {
    // 捕获并处理 ExceptionType1
} catch (ExceptionType2 e2) {
    // 捕获并处理 ExceptionType2
} finally {
    // 无论是否发生异常，都会执行的代码（cleanup code）
}

// 组合一：try-catch（最常见）
try {
    int result = 10 / 0; // 抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("捕获到算术异常: " + e.getMessage());
}
 
// 组合二：try-finally（不捕获，只做清理）
try {
    // 执行某些操作
    riskyOperation();
} finally {
    // 不管成功失败，都要清理
    cleanup();
}
 
// 组合三：try-catch-finally（完整形式）
try {
    riskyOperation();
} catch (IOException e) {
    log.error("IO异常", e);
} finally {
    cleanup();
}

try {
    String text = null;       // 模拟空指针场景
    text.length();            // 抛出 NullPointerException
} catch (NullPointerException e) {
    // 第一个 catch：精确匹配 NullPointerException
    System.out.println("空指针异常");
} catch (RuntimeException e) {
    // 第二个 catch：更宽泛的父类
    // 如果第一个没匹配上，才轮到这里
    System.out.println("运行时异常");
} catch (Exception e) {
    // 第三个 catch：最宽泛的兜底
    System.out.println("通用异常");
}

try {
    // 可能抛出多种异常
    parseAndProcess(input);
} catch (NumberFormatException | IllegalArgumentException e) {
    // 用竖线合并处理，减少重复代码
    // 注意：这里的 e 是隐式 final 的，不能重新赋值
    System.out.println("输入格式有误: " + e.getMessage());
} catch (IOException e) {
    System.out.println("IO异常: " + e.getMessage());
}

public static void scenario1() {
    try {
        System.out.println("1. try 块执行");       // 第一步：正常执行
    } catch (Exception e) {
        System.out.println("2. catch 块执行");      // 跳过：没有异常，不进入 catch
    } finally {
        System.out.println("3. finally 块执行");    // 第二步：finally 一定执行
    }
    System.out.println("4. try-catch-finally 之后"); // 第三步：继续往下
}
// 输出：1 → 3 → 4

public static void scenario2() {
    try {
        System.out.println("1. try 块开始");        // 第一步
        int x = 1 / 0;                              // 第二步：抛出异常，try 剩余代码跳过
        System.out.println("1.5 这行不会执行");      // 跳过
    } catch (ArithmeticException e) {
        System.out.println("2. catch 捕获异常");     // 第三步：匹配成功，进入 catch
    } finally {
        System.out.println("3. finally 块执行");     // 第四步：finally 一定执行
    }
    System.out.println("4. 程序继续");               // 第五步：异常已被处理，正常继续
}
// 输出：1 → 2 → 3 → 4

public static void scenario3() {
    try {
        System.out.println("1. try 块开始");        // 第一步
        int x = 1 / 0;                              // 第二步：抛出 ArithmeticException
    } catch (NullPointerException e) {
        // 类型不匹配，跳过这个 catch
        System.out.println("2. 这行不会执行");
    } finally {
        System.out.println("3. finally 仍然执行");   // 第三步：finally 照样执行
    }
    // 第四步：异常未被处理，这行不会执行，异常向上传播
    System.out.println("4. 这行不会执行");
}
// 输出：1 → 3 → 然后异常向调用者传播

// 情况一：JVM 被强制终止
try {
    System.out.println("try 执行");
    System.exit(0);  // 直接终止 JVM，finally 不会执行
} finally {
    System.out.println("finally 不会执行"); // 永远不会打印
}
 
// 情况二：守护线程（Daemon Thread）被终止
// 当所有非守护线程结束时，JVM 退出，守护线程中的 finally 可能来不及执行
 
// 情况三：线程被 kill（操作系统层面强杀进程）
// 这属于 JVM 之外的力量，finally 自然无能为力

public static int testReturn1() {
    try {
        System.out.println("try 执行");
        return 1;  // 准备返回 1，但先等 finally 执行完
    } finally {
        System.out.println("finally 执行"); // 在 return 之前执行
    }
}
// 输出：try 执行 → finally 执行
// 返回值：1

public static int testReturn2() {
    try {
        return 1;  // 暂存返回值 1
    } finally {
        return 2;  // finally 中的 return 直接覆盖，最终返回 2
    }
}
// 返回值：2（不是 1！）

public static int dangerousMethod() {
    try {
        throw new RuntimeException("出大事了！"); // 抛出异常
    } finally {
        return 0; // 异常被吞掉了！调用者收到的是 0，完全不知道出了异常
    }
}
// 返回值：0（异常消失了，非常危险）

public static int testReturn3() {
    int result = 10;                    // 初始值 10
    try {
        return result;                  // 暂存返回值 10（值拷贝）
    } finally {
        result = 20;                    // 修改局部变量为 20
        System.out.println("finally 中 result = " + result); // 打印 20
    }
}
// 返回值：10（不是 20！）
// 原因：return 时已经把 10 拷贝到了返回值槽位，finally 修改的是局部变量，不影响已暂存的值

public static List<String> testReturn4() {
    List<String> list = new ArrayList<>();  // 创建一个空列表
    try {
        list.add("try");                    // 添加元素
        return list;                        // 暂存的是引用（指向同一个对象）
    } finally {
        list.add("finally");               // 通过同一个引用修改对象内容
    }
}
// 返回值：["try", "finally"]
// 原因：暂存的是引用的拷贝，但引用指向的是同一个堆上的对象
//       finally 通过这个引用修改了对象内容，所以返回的对象也包含了修改

// ===== 基本类型（值拷贝） =====
//
//  局部变量表          返回值槽位（操作数栈）
//  ┌──────────┐       ┌──────────┐
//  │ result=10│──拷贝──▶│ 暂存值=10│
//  └──────────┘       └──────────┘
//       │
//  finally 修改为 20
//       ▼
//  ┌──────────┐       ┌──────────┐
//  │ result=20│       │ 暂存值=10│ ← 不受影响，最终返回 10
//  └──────────┘       └──────────┘
//
//
// ===== 引用类型（引用拷贝，指向同一对象） =====
//
//  局部变量表          返回值槽位           堆内存
//  ┌──────────┐       ┌──────────┐       ┌─────────────────┐
//  │ list=0x88│──拷贝──▶│ 暂存=0x88│──────▶│ ["try"]         │
//  └──────────┘       └──────────┘       └─────────────────┘
//       │                                        ▲
//  finally: list.add("finally")                  │
//       │                                        │
//       └──────── 通过 0x88 修改 ────────────────┘
//                                         ┌─────────────────┐
//                                         │ ["try","finally"]│ ← 返回的对象被修改了
//                                         └─────────────────┘

public static int testCatchReturn() {
    try {
        int x = 1 / 0;                     // 抛出 ArithmeticException
        return 1;                           // 跳过
    } catch (ArithmeticException e) {
        System.out.println("catch 执行");
        return 2;                           // 暂存返回值 2
    } finally {
        System.out.println("finally 执行"); // 在 catch 的 return 之前执行
    }
}
// 输出：catch 执行 → finally 执行
// 返回值：2

public static void finallyThrows() {
    try {
        throw new RuntimeException("try 中的异常");   // 原始异常
    } catch (RuntimeException e) {
        throw new RuntimeException("catch 中的异常");  // 准备抛出
    } finally {
        throw new RuntimeException("finally 中的异常"); // 覆盖前面的异常！
    }
}
// 最终抛出的是："finally 中的异常"
// "catch 中的异常" 被吞掉了，丢失了！

public static void safeFinally() {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream("data.txt");
        // 读取文件...
    } catch (IOException e) {
        System.err.println("读取失败: " + e.getMessage());
    } finally {
        // finally 中的操作也可能抛异常，需要额外保护
        if (fis != null) {
            try {
                fis.close();  // close() 可能抛 IOException
            } catch (IOException e) {
                System.err.println("关闭流失败: " + e.getMessage());
                // 记录日志但不再向上抛，避免覆盖原始异常
            }
        }
    }
}

// 源代码
public static int demo() {
    int x = 1;
    try {
        return x;    // (1) 将 x 的值 load 到操作数栈
                     // (2) 将操作数栈顶的值 store 到一个临时槽位（暂存返回值）
                     // (3) 跳转到 finally 块
    } finally {
        x = 99;     // (4) 修改局部变量 x 为 99
                     // (5) finally 结束，从临时槽位 load 暂存的返回值
                     // (6) 执行 ireturn，返回暂存值 1
    }
}

public static int puzzle() {
    int a = 10;
    try {
        a = 20;
        return a;       // 行 A
    } catch (Exception e) {
        a = 30;
        return a;       // 行 B
    } finally {
        a = 40;         // 行 C
    }
}

// Java 7 之前的传统写法：手动关闭资源
BufferedReader reader = null;       // 声明在 try 外部，以便 finally 中访问
try {
    reader = new BufferedReader(      // 创建资源
        new FileReader("data.txt")
    );
    String line = reader.readLine();  // 使用资源读取数据
    System.out.println(line);         // 输出读取到的内容
} catch (IOException e) {
    e.printStackTrace();              // 捕获并打印 IO 异常
} finally {
    // finally 块：无论是否异常都会执行
    if (reader != null) {             // 必须判空，否则可能 NPE
        try {
            reader.close();           // 关闭资源本身也可能抛异常！
        } catch (IOException e) {
            e.printStackTrace();      // 关闭失败的异常往往被吞掉
        }
    }
}

// 多资源的传统写法——嵌套地狱
InputStream in = null;                // 输入流声明
OutputStream out = null;              // 输出流声明
try {
    in = new FileInputStream("src.bin");    // 打开输入流
    out = new FileOutputStream("dst.bin");  // 打开输出流
    byte[] buf = new byte[1024];            // 创建缓冲区
    int len;                                // 记录每次读取的字节数
    while ((len = in.read(buf)) != -1) {    // 循环读取
        out.write(buf, 0, len);             // 写入目标文件
    }
} catch (IOException e) {
    e.printStackTrace();                    // 处理异常
} finally {
    // 必须按照"后开先关"的顺序逐个关闭
    if (out != null) {                      // 先关 out
        try { out.close(); } catch (IOException e) { e.printStackTrace(); }
    }
    if (in != null) {                       // 再关 in
        try { in.close(); } catch (IOException e) { e.printStackTrace(); }
    }
}

// try-with-resources 基本语法
// 资源在圆括号内声明，作用域仅限 try 块
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
    String line = reader.readLine();  // 使用资源
    System.out.println(line);         // 输出内容
}   // ← 这里编译器自动插入 reader.close()
catch (IOException e) {
    e.printStackTrace();              // 处理异常
}
// 注意：catch 和 finally 都是可选的

// 多资源的 try-with-resources 写法
try (
    InputStream in = new FileInputStream("src.bin");     // 资源1：先声明
    OutputStream out = new FileOutputStream("dst.bin")   // 资源2：后声明
) {
    byte[] buf = new byte[1024];       // 创建缓冲区
    int len;                           // 读取长度
    while ((len = in.read(buf)) != -1) {  // 循环读取
        out.write(buf, 0, len);           // 写入目标
    }
}   // ← 自动关闭顺序：先 out.close()，再 in.close()
catch (IOException e) {
    e.printStackTrace();               // 统一处理异常
}

// 自定义资源类：实现 AutoCloseable 接口
public class DatabaseSession implements AutoCloseable {
 
    private final String sessionId;   // 会话标识
 
    // 构造方法：模拟打开数据库会话
    public DatabaseSession(String id) {
        this.sessionId = id;                          // 保存会话 ID
        System.out.println("Session opened: " + id);  // 打印开启信息
    }
 
    // 业务方法：执行查询
    public void query(String sql) {
        System.out.println("[" + sessionId + "] Executing: " + sql);  // 打印 SQL
    }
 
    // 实现 close() 方法：释放资源
    @Override
    public void close() throws Exception {
        System.out.println("Session closed: " + sessionId);  // 打印关闭信息
        // 实际项目中这里会释放连接、清理缓存等
    }
}

// 使用自定义资源
try (DatabaseSession session = new DatabaseSession("S-001")) {
    session.query("SELECT * FROM users");   // 执行查询
}   // ← 自动调用 session.close()
// 输出：
// Session opened: S-001
// [S-001] Executing: SELECT * FROM users
// Session closed: S-001

// 你写的代码
try (BufferedReader r = new BufferedReader(new FileReader("a.txt"))) {
    System.out.println(r.readLine());
}

// 编译器生成的等价代码（简化版）
BufferedReader r = new BufferedReader(new FileReader("a.txt"));  // 创建资源
Throwable primaryEx = null;          // 用于记录 try 块中的原始异常
try {
    System.out.println(r.readLine());  // 执行业务逻辑
} catch (Throwable t) {
    primaryEx = t;                     // 捕获原始异常并记录
    throw t;                           // 重新抛出
} finally {
    if (r != null) {                   // 资源非空才关闭
        if (primaryEx != null) {       // 如果 try 块已经有异常
            try {
                r.close();             // 尝试关闭资源
            } catch (Throwable suppressed) {
                // 关闭时的异常不会覆盖原始异常
                // 而是作为"被抑制的异常"附加上去
                primaryEx.addSuppressed(suppressed);
            }
        } else {
            r.close();                 // try 块正常结束，直接关闭
        }
    }
}

// 演示 Suppressed Exception 机制
public class SuppressedDemo {
 
    // 自定义资源：close() 时故意抛异常
    static class FaultyResource implements AutoCloseable {
        @Override
        public void close() throws Exception {
            throw new RuntimeException("close() 爆炸了!");  // 关闭时抛异常
        }
    }
 
    public static void main(String[] args) {
        try (FaultyResource res = new FaultyResource()) {
            throw new IllegalStateException("业务逻辑出错!");  // try 块抛异常
        } catch (Exception e) {
            // 主异常：IllegalStateException
            System.out.println("主异常: " + e.getMessage());
 
            // 被抑制的异常：RuntimeException from close()
            Throwable[] suppressed = e.getSuppressed();       // 获取被抑制的异常数组
            for (Throwable t : suppressed) {
                System.out.println("被抑制: " + t.getMessage());
            }
        }
    }
}
// 输出：
// 主异常: 业务逻辑出错!
// 被抑制: close() 爆炸了!

// Java 9+ 增强写法
BufferedReader reader = new BufferedReader(new FileReader("data.txt"));  // 外部声明
// reader 是 effectively final（声明后未被重新赋值）
try (reader) {                        // 直接引用，无需重新声明
    System.out.println(reader.readLine());
} catch (IOException e) {
    e.printStackTrace();
}

// 多个 effectively final 资源
Connection conn = DriverManager.getConnection(url);    // 数据库连接
PreparedStatement ps = conn.prepareStatement(sql);     // 预编译语句
 
try (conn; ps) {                      // Java 9+：直接引用多个已有变量
    ResultSet rs = ps.executeQuery();  // 执行查询
    while (rs.next()) {
        System.out.println(rs.getString(1));  // 输出结果
    }
}

// 验证关闭顺序
public class CloseOrderDemo {
 
    // 自定义资源：打印创建和关闭时机
    static class NamedResource implements AutoCloseable {
        private final String name;                    // 资源名称
 
        NamedResource(String name) {
            this.name = name;                         // 保存名称
            System.out.println("  打开: " + name);    // 打印打开信息
        }
 
        @Override
        public void close() {
            System.out.println("  关闭: " + name);    // 打印关闭信息
        }
    }
 
    public static void main(String[] args) {
        System.out.println("=== 开始 ===");
        try (
            NamedResource a = new NamedResource("A");   // 第1个声明
            NamedResource b = new NamedResource("B");   // 第2个声明
            NamedResource c = new NamedResource("C")    // 第3个声明
        ) {
            System.out.println("  --- 执行业务逻辑 ---");
        }
        System.out.println("=== 结束 ===");
    }
}
// 输出：
// === 开始 ===
//   打开: A
//   打开: B
//   打开: C
//   --- 执行业务逻辑 ---
//   关闭: C    ← 后声明的先关闭
//   关闭: B
//   关闭: A    ← 先声明的最后关闭
// === 结束 ===

声明顺序（入栈）        关闭顺序（出栈）
    ┌───┐                  ┌───┐
    │ A │ ← 先声明          │ C │ ← 先关闭
    ├───┤                  ├───┤
    │ B │                  │ B │
    ├───┤                  ├───┤
    │ C │ ← 后声明          │ A │ ← 后关闭
    └───┘                  └───┘
   PUSH 顺序              POP 顺序

// 资源初始化部分失败的场景
static class BadResource implements AutoCloseable {
    BadResource() {
        throw new RuntimeException("构造失败!");  // 构造时直接抛异常
    }
    @Override
    public void close() {
        System.out.println("BadResource closed");
    }
}
 
public static void main(String[] args) {
    try (
        NamedResource a = new NamedResource("A");   // 成功创建
        BadResource bad = new BadResource();         // 构造失败！抛异常
        NamedResource c = new NamedResource("C")    // 永远不会执行到
    ) {
        System.out.println("业务逻辑");              // 永远不会执行到
    } catch (Exception e) {
        System.out.println("捕获: " + e.getMessage());
    }
}
// 输出：
//   打开: A
//   关闭: A          ← 已成功创建的资源 A 被正确关闭
//   捕获: 构造失败!

// 方式一：只声明最外层（通常足够）
// 大多数装饰器流的 close() 会级联关闭底层流
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    // BufferedReader.close() 内部会调用 FileReader.close()
    String line = br.readLine();
}
 
// 方式二：分别声明（更安全，推荐）
// 如果 BufferedReader 构造函数抛异常，FileReader 仍能被关闭
try (
    FileReader fr = new FileReader("data.txt");       // 底层流单独声明
    BufferedReader br = new BufferedReader(fr)         // 装饰器流
) {
    String line = br.readLine();
}

// JDBC 标准资源管理模式
String url = "jdbc:mysql://localhost:3306/mydb";      // 数据库 URL
String sql = "SELECT id, name FROM users WHERE age > ?";  // SQL 语句
 
try (
    Connection conn = DriverManager.getConnection(url, "root", "pwd");  // 获取连接
    PreparedStatement ps = conn.prepareStatement(sql)                   // 预编译 SQL
) {
    ps.setInt(1, 18);                          // 设置参数：age > 18
    try (ResultSet rs = ps.executeQuery()) {   // ResultSet 也是 AutoCloseable
        while (rs.next()) {                    // 遍历结果集
            int id = rs.getInt("id");          // 获取 id 列
            String name = rs.getString("name");// 获取 name 列
            System.out.println(id + ": " + name);
        }
    }   // ← rs 自动关闭
}   // ← ps 先关闭，conn 后关闭

// 幂等 close() 的标准写法
public class ManagedConnection implements AutoCloseable {
 
    private Connection conn;          // 底层数据库连接
    private boolean closed = false;   // 关闭状态标记
 
    public ManagedConnection(String url) throws SQLException {
        this.conn = DriverManager.getConnection(url);  // 获取连接
    }
 
    @Override
    public void close() throws SQLException {
        if (!closed) {                // 只有未关闭时才执行
            closed = true;            // 先标记为已关闭
            conn.close();             // 再实际关闭连接
            System.out.println("连接已释放");
        }
        // 重复调用时什么都不做，不会抛异常
    }
}

// ❌ 陷阱1：在 try 块内部赋值 null，不影响自动关闭
try (BufferedReader r = new BufferedReader(new FileReader("a.txt"))) {
    // r = null;  // 编译错误！TWR 中声明的变量是隐式 final 的
    // 你无法在 try 块内重新赋值
}
 
// ❌ 陷阱2：返回的资源不要用 TWR 管理
public InputStream openStream() {
    // 错误！方法返回后资源就被关闭了，调用者拿到的是已关闭的流
    try (InputStream is = new FileInputStream("data.bin")) {
        return is;  // ← is 在 return 之后立即被 close()
    }
    // 正确做法：直接 return new FileInputStream("data.bin");
    // 让调用者负责关闭
}
 
// ❌ 陷阱3：不要在 TWR 圆括号中放非资源类型的表达式
// try (int x = 42) { }  // 编译错误：int 没有实现 AutoCloseable

public class TWRQuiz {
    static class Res implements AutoCloseable {
        String name;
        Res(String name) {
            this.name = name;
            System.out.print("O" + name + " ");
        }
        @Override
        public void close() {
            System.out.print("C" + name + " ");
        }
    }
 
    public static void main(String[] args) {
        try (Res a = new Res("1"); Res b = new Res("2")) {
            System.out.print("T ");
            throw new RuntimeException();
        } catch (Exception e) {
            System.out.print("E ");
        } finally {
            System.out.print("F ");
        }
    }
}

throw new 异常类型("异常描述信息");

public class UserService {
 
    // 注册用户的方法，要求用户名不能为空
    public void register(String username) {
        // 参数校验：如果用户名为 null 或空串，主动抛出异常
        if (username == null || username.trim().isEmpty()) {
            // throw 语句：创建异常对象并立即抛出
            // IllegalArgumentException 是 RuntimeException 的子类（Unchecked）
            throw new IllegalArgumentException("用户名不能为空");
        }
 
        // 如果上面的 throw 被执行，下面这行代码永远不会到达
        System.out.println("注册成功：" + username);
    }
}

public void demo() {
    throw new RuntimeException("出错了");
    System.out.println("这行永远执行不到"); // 编译错误：unreachable statement
}

public void demo(int value) {
    if (value < 0) {
        throw new IllegalArgumentException("值不能为负数"); // 只在条件满足时抛出
    }
    // 这行代码是可达的，因为 throw 在 if 块内
    System.out.println("值为：" + value);
}

// 合法但极不推荐——Error 应该留给 JVM 自己抛
throw new StackOverflowError("手动抛出 Error，别这么干");
 
// 合法且常见——抛出 Checked Exception
throw new IOException("文件读取失败");
 
// 合法且最常见——抛出 Unchecked Exception
throw new NullPointerException("对象引用为空");

public void process() {
    // 预先创建异常对象
    RuntimeException cached = new RuntimeException("预创建的异常");
 
    // ... 一些业务逻辑 ...
 
    // 在需要的时候抛出已有的异常引用
    throw cached; // 注意：此时异常的堆栈信息是创建时的，不是 throw 时的
}

// throws 声明该方法可能抛出 IOException
public void readFile(String path) throws IOException {
    // 方法体
}
 
// 可以声明多个异常，用逗号分隔
public void transfer(String from, String to, double amount)
        throws InsufficientFundsException, AccountNotFoundException {
    // 方法体
}

public class FileProcessor {
 
    // 方法声明抛出 IOException（Checked Exception）
    // 调用者必须处理这个异常
    public String readContent(String filePath) throws IOException {
        // FileReader 构造器可能抛出 FileNotFoundException（IOException 的子类）
        FileReader reader = new FileReader(filePath);
        // BufferedReader 的 readLine() 可能抛出 IOException
        BufferedReader br = new BufferedReader(reader);
        // 读取第一行并返回
        String line = br.readLine();
        // 关闭资源
        br.close();
        return line;
    }
}

public class App {
 
    // 方案一：继续 throws 向上传播
    public void approach1() throws IOException {
        FileProcessor processor = new FileProcessor();
        // 因为 approach1 也声明了 throws IOException，所以这里不需要 try-catch
        String content = processor.readContent("/data/config.txt");
        System.out.println(content);
    }
 
    // 方案二：try-catch 就地处理
    public void approach2() {
        FileProcessor processor = new FileProcessor();
        try {
            // 在 try 块中调用可能抛出异常的方法
            String content = processor.readContent("/data/config.txt");
            System.out.println(content);
        } catch (IOException e) {
            // 捕获并处理异常
            System.err.println("读取文件失败：" + e.getMessage());
        }
    }
}

// 合法，但编译器不会强制调用者处理 IllegalArgumentException
public void validate(int age) throws IllegalArgumentException {
    if (age < 0 || age > 150) {
        throw new IllegalArgumentException("年龄不合法：" + age);
    }
}
 
// 调用者可以完全不做任何异常处理，编译器不会报错
public void caller() {
    validate(-5); // 编译通过，即使 validate 声明了 throws
}

public class OrderService {
 
    // throws 声明：告诉调用者本方法可能抛出 InsufficientBalanceException
    public void placeOrder(String userId, double amount)
            throws InsufficientBalanceException {
 
        // 查询用户余额
        double balance = queryBalance(userId);
 
        // 业务校验：余额不足时，用 throw 主动抛出异常
        if (balance < amount) {
            // throw 执行：创建并抛出 Checked Exception
            throw new InsufficientBalanceException(
                "余额不足，当前余额：" + balance + "，订单金额：" + amount
            );
        }
 
        // 正常下单逻辑
        System.out.println("下单成功，扣款：" + amount);
    }
 
    // 模拟查询余额
    private double queryBalance(String userId) {
        return 100.0; // 假设余额为 100
    }
}

// 编译错误！throw 了 Checked Exception 但既没 catch 也没 throws
public void broken() {
    throw new IOException("这行代码会导致编译失败");
    // 错误信息：Unhandled exception: java.io.IOException
}

// 完全合法：RuntimeException 不需要 throws 声明
public void works() {
    throw new RuntimeException("Unchecked，编译器不管");
}

public class PropagationDemo {
 
    // 第三层：异常的源头，throw 创建并抛出异常
    public void level3() throws SQLException {
        // 模拟数据库操作失败
        throw new SQLException("数据库连接超时");
    }
 
    // 第二层：不处理，通过 throws 继续向上传播
    public void level2() throws SQLException {
        // 调用 level3，异常会穿透 level2 继续向上
        level3();
        // 如果 level3 抛出异常，这行不会执行
        System.out.println("level2 正常结束");
    }
 
    // 第一层：最终在这里 catch 处理
    public void level1() {
        try {
            // 调用 level2
            level2();
        } catch (SQLException e) {
            // 异常在这里被捕获并处理
            System.err.println("捕获到异常：" + e.getMessage());
            // 输出：捕获到异常：数据库连接超时
        }
    }
}

// 父类
public class Animal {
    // 父类方法声明抛出 IOException
    public void eat() throws IOException {
        System.out.println("Animal eating...");
    }
}
 
// 子类——合法的各种情况
public class Dog extends Animal {
 
    // ✅ 合法：不声明任何异常（比父类更窄）
    @Override
    public void eat() {
        System.out.println("Dog eating...");
    }
}
 
public class Cat extends Animal {
 
    // ✅ 合法：声明 IOException 的子类（比父类更窄）
    @Override
    public void eat() throws FileNotFoundException {
        // FileNotFoundException 是 IOException 的子类
        System.out.println("Cat eating...");
    }
}
 
public class Bird extends Animal {
 
    // ❌ 编译错误：声明了父类方法中没有的 Checked Exception（比父类更宽）
    @Override
    public void eat() throws SQLException {
        // SQLException 不是 IOException 的子类
        // 编译器报错：overridden method does not throw SQLException
        System.out.println("Bird eating...");
    }
}

public class Fish extends Animal {
 
    // ✅ 合法：Unchecked Exception 不受 throws 约束
    @Override
    public void eat() throws RuntimeException {
        throw new UnsupportedOperationException("鱼不这样吃东西");
    }
}

// ========== DAO 层：throw early，发现问题立即抛出 ==========
public class UserDao {
 
    public User findById(Long id) throws DataAccessException {
        // 参数校验：尽早发现问题，尽早抛出
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("用户 ID 不合法：" + id);
        }
 
        // 模拟数据库查询
        try {
            // ... JDBC 操作 ...
            return null; // 假设没查到
        } catch (SQLException e) {
            // 将底层异常转换为业务异常后重新抛出
            throw new DataAccessException("查询用户失败，ID=" + id, e);
        }
    }
}
 
// ========== Service 层：throws 传播，不做多余处理 ==========
public class UserService {
 
    private UserDao userDao = new UserDao();
 
    // 不在这里 catch，通过 throws 继续向上传播
    public User getUser(Long id) throws DataAccessException {
        User user = userDao.findById(id);
        if (user == null) {
            throw new UserNotFoundException("用户不存在，ID=" + id);
        }
        return user;
    }
}
 
// ========== Controller 层：catch late，统一处理 ==========
public class UserController {
 
    private UserService userService = new UserService();
 
    public void handleRequest(Long userId) {
        try {
            // 调用 Service 层
            User user = userService.getUser(userId);
            System.out.println("查询成功：" + user);
        } catch (UserNotFoundException e) {
            // 用户不存在——返回 404
            System.err.println("404：" + e.getMessage());
        } catch (DataAccessException e) {
            // 数据库异常——返回 500
            System.err.println("500：" + e.getMessage());
        } catch (IllegalArgumentException e) {
            // 参数非法——返回 400
            System.err.println("400：" + e.getMessage());
        }
    }
}

// ❌ 反模式：用异常控制流程
public int findIndex(int[] arr, int target) {
    try {
        for (int i = 0; ; i++) {
            if (arr[i] == target) {
                throw new RuntimeException(String.valueOf(i)); // 别这么干！
            }
        }
    } catch (ArrayIndexOutOfBoundsException e) {
        return -1; // 用越界异常表示"没找到"
    } catch (RuntimeException e) {
        return Integer.parseInt(e.getMessage()); // 用异常消息传递返回值
    }
}
 
// ✅ 正确做法：普通循环 + 条件判断
public int findIndex(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i; // 直接返回
        }
    }
    return -1; // 没找到返回 -1
}

// ❌ 不推荐：throws Exception 太宽泛，调用者无法精确处理
public void doSomething() throws Exception {
    // ...
}
 
// ✅ 推荐：声明具体的异常类型
public void doSomething() throws FileNotFoundException, ParseException {
    // 调用者可以针对不同异常做不同处理
}

public class Parent {
    public void action() throws FileNotFoundException {
        // ...
    }
}
 
public class Child extends Parent {
    @Override
    public void action() throws IOException {
        // ...
    }
}

/**
 * 业务异常：当用户账户余额不足以完成交易时抛出。
 * 继承 Exception，属于 Checked Exception，调用方必须处理。
 */
public class InsufficientBalanceException extends Exception {
 
    // ---- 四个标准构造方法，与 java.lang.Exception 保持一致 ----
 
    // 1. 无参构造：最简形式，仅标识异常类型
    public InsufficientBalanceException() {
        super(); // 调用父类 Exception 的无参构造
    }
 
    // 2. 带消息构造：附带人类可读的错误描述
    public InsufficientBalanceException(String message) {
        super(message); // 将 message 传递给父类，可通过 getMessage() 获取
    }
 
    // 3. 带消息 + 原因构造：用于异常链（Exception Chaining）
    public InsufficientBalanceException(String message, Throwable cause) {
        super(message, cause); // 同时保留描述信息和底层异常
    }
 
    // 4. 仅原因构造：当底层异常本身已足够说明问题时使用
    public InsufficientBalanceException(Throwable cause) {
        super(cause); // message 会自动取 cause.toString()
    }
}

// 场景 1：无参 —— 异常类型本身就是全部信息
throw new InsufficientBalanceException();
 
// 场景 2：带消息 —— 最常用，附带业务上下文
throw new InsufficientBalanceException(
    "用户 [userId] 余额 50.00 元，不足以支付 120.00 元"
);
 
// 场景 3：带消息 + 原因 —— 包装底层异常，形成异常链
try {
    paymentGateway.deduct(amount); // 可能抛出 IOException
} catch (IOException e) {
    // 将底层 IO 异常包装为业务异常，保留完整调用链
    throw new InsufficientBalanceException("扣款网关调用失败", e);
}
 
// 场景 4：仅原因 —— 底层异常已经说明一切
catch (SQLException e) {
    throw new InsufficientBalanceException(e);
}

/**
 * 增强版余额不足异常：携带账户余额和所需金额。
 * 继承 RuntimeException，属于 Unchecked，不强制调用方处理。
 */
public class InsufficientBalanceException extends RuntimeException {
 
    private final String accountId;  // 出问题的账户 ID
    private final double balance;    // 当前实际余额
    private final double required;   // 本次操作所需金额
 
    /**
     * 核心构造方法：接收所有业务字段
     * @param accountId 账户标识
     * @param balance   当前余额
     * @param required  所需金额
     */
    public InsufficientBalanceException(String accountId, double balance, double required) {
        // 调用父类构造，自动生成格式化的 message
        super(String.format(
            "账户 [%s] 余额不足: 当前 %.2f, 需要 %.2f, 差额 %.2f",
            accountId, balance, required, required - balance
        ));
        this.accountId = accountId; // 保存账户 ID
        this.balance = balance;     // 保存当前余额
        this.required = required;   // 保存所需金额
    }
 
    // 支持异常链的构造方法
    public InsufficientBalanceException(String accountId, double balance,
                                         double required, Throwable cause) {
        super(String.format(
            "账户 [%s] 余额不足: 当前 %.2f, 需要 %.2f",
            accountId, balance, required
        ), cause); // 将 cause 传递给父类
        this.accountId = accountId;
        this.balance = balance;
        this.required = required;
    }
 
    // ---- Getter 方法：让 catch 代码能提取结构化数据 ----
 
    public String getAccountId() { return accountId; }  // 获取账户 ID
    public double getBalance()   { return balance; }     // 获取当前余额
    public double getRequired()  { return required; }    // 获取所需金额
 
    // 计算差额，方便上层直接使用
    public double getDeficit() {
        return required - balance; // 差额 = 所需 - 当前余额
    }
}