5.3 异常处理及语法

1. try-catch：自己换备胎

先把 5.1 炸掉的程序改造一遍——用 try 把风险代码圈住：

public class Demo03 {
    public static void main(String[] args) {
        try {
            int r = 10 / 0;                    // 风险代码
            System.out.println("算完了");       // 炸点之后，不执行
        } catch (ArithmeticException e) {
            // e 就是 5.1 说的那个"事故报告"对象
            System.out.println("接住了：" + e.getMessage());
        }
        System.out.println("程序结束");         // 正常执行！
    }
}

输出：

接住了：/ by zero
程序结束

执行流程（对着上面代码走一遍）：

1. try 里的代码正常执行——没出事，catch 整个跳过，直接跑到后面；
2. 一旦出事（10 / 0 炸出 ArithmeticException 对象）：try 里剩余代码立刻不跑，JVM 拿着异常对象来匹配 catch 括号里的类型；
3. 类型对上 → 进入 catch，变量 e 接住这个对象——e.getMessage() 取事故消息；
4. catch 跑完 → 程序继续，后面的代码照常执行。

对照 5.1：同一行 10 / 0，没有 try-catch 时"程序结束"永远打不出来；现在程序体面地跑完了。catch 的类型匹配本质是 4.4 的多态：e 声明为 ArithmeticException 类型，实际接住的是它的对象——"编译看左，运行看右"在异常这又上岗了。

2. catch 的匹配规矩

规矩一：类型要接得住。catch 里写的是异常类型，抛出对象必须是它的类型（或子类）才接得住——接不住就当没写，照样炸：

try {
    int r = 10 / 0;
} catch (NullPointerException e) {   // 拿空指针的手套去接算术异常
    System.out.println("接住了");
}
// 结果：炸。ArithmeticException 不是 NullPointerException，接不住

规矩二：多个 catch 从上到下挨个试，命中即走（只进一个）：

try {
    int[] arr = new int[3];
    arr[5] = 1;
} catch (ArithmeticException e) {
    System.out.println("算术问题");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("越界了");      // 命中这条
} catch (Exception e) {
    System.out.println("兜底");
}

规矩三（大坑）：父类不能写在子类前面——Exception 是所有异常的父类，放第一个就把所有异常全接了，后面的子类 catch 永远轮不到。编译器直接报错："已捕获到异常"。正确顺序：子类在前，父类（Exception）殿后兜底。

3. finally：收尾专用，无论如何都跑

try {
    int r = 10 / 0;                        // 炸
} catch (ArithmeticException e) {
    System.out.println("接住");
} finally {
    System.out.println("finally：收尾工作");
}

finally 里的代码两条路线都跑：没出事 → try 跑完跑 finally；出了事 → catch 跑完跑 finally。连 return 都拦不住它。

用途一句话：无论结局如何都必须做的事——关文件、断开网络、释放资源、恢复状态。对照第 1 节：万一炸了，"释放资源"的代码可不能跟着一起跳过——放进 finally 就跑不丢。

4. throw 与 throws：甩锅系

catch 是"接"，另两个关键词管"甩"：

throw：主动抛出（动作）

写在方法体里，后面跟一个异常对象——意思是"这里出问题了，我现在就甩出去"：

static void setScore(int score) {
    if (score < 0 || score > 100) {
        // 3.3 的 setter 打印升级版：安检不过，直接甩异常
        throw new IllegalArgumentException("分数必须在 0~100 之间");
    }
    this.score = score;
}

throws：声明甩出（声明）

写在方法签名的括号后面，后面跟异常类名（可多个）——意思是"我这个方法可能会甩这种异常，我不管，谁调用谁负责"：

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

两者对照（差一个 s，差很远）

5.2 的 Unhandled exception 至此有了两条活路：受检异常要么 try-catch 接住，要么方法签名 throws 甩出去。但甩不是无限的——一层层甩到 main 还没人接，就走 5.1 的老路：打印事故报告，程序中断。

5. 动手：一套完整的接与甩

在 IDEA05 新建 Demo03（照第 1 节改造版）和下面这个综合版：

public class Demo04 {
    public static void main(String[] args) {
        try {
            int r = divide(10, 0);              // 调用会甩异常的方法
            System.out.println("结果：" + r);    // 不执行
        } catch (ArithmeticException e) {
            System.out.println("接住：" + e.getMessage());
        } finally {
            System.out.println("finally：收尾");
        }
        System.out.println("程序继续跑");
    }

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

输出：

接住：除数不能为零
finally：收尾
程序继续跑

三个 30 秒实验

1. 接不住照样炸：把 catch 类型改成 NullPointerException——编译不报错，运行时还是炸（catch 匹配失败）。
2. 父类在前报错：再加一个 catch (Exception e) 放在 ArithmeticException 前面——编译报错"已捕获到异常"。
3. return 拦不住 finally：try 块末尾加 return;，finally 里的打印照样执行。

6. 常见误区

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

public void setScore(int score) {
    if (score < 0 || score > 100) {
        throw new IllegalArgumentException("分数必须在 0~100 之间");
    }
    this.score = score;
}
// 测试类：
try {
    s.setScore(-5);
} catch (IllegalArgumentException e) {
    System.out.println("录入被拦：" + e.getMessage());
} finally {
    System.out.println("录入结束");
}

8. 下一步学什么

• ☑ 5.4 抛出异常 ✅ —— throw 中断方法与不可达代码、甩锅链条层层上溯、两派甩的待遇差异、重写不能甩更大。点此复习

相关笔记

• 5.2 运行时异常与编译时异常 ← 上一篇：两派分野，本节给出两条活路
• 5.1 什么是异常 ← 异常对象 = 事故报告，catch 里的 e 就是它
• 3.3 封装性 ← setter 安检从 println 升级为 throw，封装老朋友返场
• 4.4 多态 ← catch 类型匹配 = "编译看左运行看右"又一次上岗
• 📇 Java基础 · 索引
• 🏠 返回主页