5.4 抛出异常

1. throw 甩出后，方法立刻中断

先看 throw 的"杀伤力"——它和 return 一样会结束方法，但方式完全不同：

static void check(int score) {
    if (score < 0) {
        throw new IllegalArgumentException("分数不能为负");
    }
    System.out.println("检查通过");   // score < 0 时执行不到
}

• return 是正常收工：方法体面结束，调用者拿返回值继续干活；
• throw 是拉响警报：方法非正常中断，异常对象沿着调用链往上甩。

由此还有一条硬规矩：throw 之后不能再写"可达"的代码——

static void check(int score) {
    throw new IllegalArgumentException("分数不能为负");
    System.out.println("这行永远跑不到");   // 编译报错：无法访问的语句
}

编译器直接报错 unreachable statement——和 return 后面不能写代码同理（1.x~2.x 老规矩的翻版）。想甩完还做事？把事写在 catch 那一层去。

2. throws 甩出去，谁调用谁负责

方法签名上 throws 之后，本方法对这种异常免责——但它没消失，只是换人接手。调用者拿到"可能被甩"的预告，二选一：

static void readFile() throws FileNotFoundException {
    // 自己不写预案——编译器看签名上有声明，放行
}

// 调用者 A：接住
try {
    readFile();
} catch (FileNotFoundException e) { ... }

// 调用者 B：不想接，继续甩
static void main2() throws FileNotFoundException {
    readFile();
}

可以一次声明多个：throws FileNotFoundException, IOException（逗号隔开）。

3. 甩锅链条：一层层往上，直到有人负责

把第 2 节的调用者 B 再被调用、再甩……异常就形成一条链条：

divide()  throw 甩出
   ↓ 甩
calc()    throws 不接，继续甩
   ↓ 甩
main()    二选一：接住（结局 A）／也甩给 JVM（结局 B）
   ↓ 结局 B
JVM       打印事故报告 → 程序中断（5.1 的老路）

完整代码看一遍（结局 A）：

public class Demo05 {
    public static void main(String[] args) {
        try {
            int r = calc(10, 0);
            System.out.println("结果：" + r);
        } catch (ArithmeticException e) {
            System.out.println("main 接住：" + e.getMessage());
        }
        System.out.println("程序继续");
    }

    static int calc(int a, int b) {
        return divide(a, b);              // 不接，异常穿透这层往上走
    }

    static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为零");  // 甩出
        }
        return a / b;
    }
}

注意一个细节：calc 什么都没写却"参与"了链条——异常会自动穿透没有 try-catch 的每一层，一路找下一个调用者。而 divide 抛的是运行时异常，连 throws 都可以不写（下一节说为什么）。输出：

main 接住：除数不能为零
程序继续

如果把 main 里的 try-catch 删掉、改成 main(String[] args) throws ArithmeticException——异常甩到 main 都没人接，就交给 JVM：打印事故报告，程序在炸点中断（结局 B，5.1 见过全套）。

4. 两派在"甩"上的待遇差异（5.2 收网）

5.2 埋的问题"为什么有的异常不声明也不报错"，现在能完整回答了：

static void a() {
    throw new RuntimeException("运行时异常：甩就甩了");   // 不声明，编译通过
}

static void b() throws FileNotFoundException {            // 受检异常：必须声明
    throw new FileNotFoundException("受检异常：没声明不让过");
}

编译器的账本还是那本：运行时异常多半是你自己的 bug（改代码去，甩不甩随你）；受检异常是外部风险（甩可以，但必须让每个经手人知情——知情了才好安排预案）。理解了 5.2 的"怪谁"，这一节全是自然推论。

5. 重写方法的 throws 规矩（会认）

4.1 学过方法重写，现在补一条和异常有关的规矩：子类重写方法声明的异常，不能比父类的更大——只能甩同样的、更具体的（子类异常），或者干脆不甩。

原因用 4.4 的多态一想就通：调用者拿着父类引用写代码，预案是按父类签名准备的——catch (父类异常 e)。如果子类实现甩出一个更大的、父类没预告的异常，调用者的预案就接不住了。"编译看左"管的不只是能调什么方法，还包括会甩什么异常。

class Parent {
    void work() throws IOException { }
}
class Child extends Parent {
    @Override
    void work() throws FileNotFoundException { }   // ✅ 更小，可以
    // void work() throws Exception { }            // ❌ 更大，编译报错
}

现在会认即可，学到 IO 那章用得着。

6. 动手：亲手搭一条甩锅链

在 IDEA05 新建 Demo05（照第 3 节抄），完成三个实验：

三个 30 秒实验

1. 链条穿透：在 calc 里加一行打印，运行确认 calc 的打印在异常发生前执行了——异常是从炸点开始向上找人的，穿越途中代码正常跑过。
2. throw 后写代码：在 divide 的 throw 后面加一行打印——看 unreachable statement 编译报错。
3. 结局 B 全套：把 main 的 try-catch 删掉、签名加 throws——亲眼看异常甩给 JVM 后的红字报告，和 5.1 那次一模一样（这次你知道每一行都是谁干的了）。

7. 常见误区

8. 自测题（先自己答，再展开）

static void registerUser(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负");
    }
    System.out.println("注册成功：" + age);
}

// a) 接住版：
public static void main(String[] args) {
    try {
        registerUser(-5);
    } catch (IllegalArgumentException e) {
        System.out.println("注册被拦：" + e.getMessage());
    }
    System.out.println("流程继续");
}

// b) 继续甩版：
public static void main(String[] args) /* throws IllegalArgumentException */ {
    registerUser(-5);   // 异常甩给 JVM → 打印事故报告 → "流程继续"打不出来
}

9. 下一步学什么

• ☑ 5.5 自定义异常类 ✅ —— 印一张自己的「事故报告」：诞生三步 + super(message) 消息传递链 + 受检/运行时选型，5.3 埋的钩子正式收网。点此复习

相关笔记

• 5.3 异常处理及语法 ← 上一篇：throw/throws 认脸，本节讲甩出后的运行细节
• 5.2 运行时异常与编译时异常 ← 两派待遇差异是本节第 4 节的谜底
• 5.1 什么是异常 ← 结局 B 就是本篇开头那张"事故现场"的全套流程
• 4.4 多态 ← 重写不能甩更大异常：编译看左的延伸
• 3.4 构造方法 / 2.6 方法 ← 方法中断与调用的老底子
• 📇 Java基础 · 索引
• 🏠 返回主页