Java 捕获多个异常：从基础语法到最佳实践

1. 引言

在 Java 开发中，异常处理是保证程序健壮性的重要手段。无论是文件读写、网络请求还是数据库操作，异常无处不在。而捕获多个异常，则是每个 Java 开发者都必须掌握的核心技能。

很多初学者在编写异常处理代码时，常常会遇到这样的困惑：一个 try 块中可能抛出多种不同类型的异常，到底应该写多个 catch 块，还是用一个 catch 块统一处理？多异常捕获（multi-catch）和异常链（exception chaining）又有什么区别？

本文将系统性地讲解 Java 捕获多个异常的几种方式，从最基础的多个 catch 块，到 Java 7 引入的 multi-catch 语法，再到异常屏蔽（exception suppression）等进阶话题，帮助你写出更健壮、更易维护的异常处理代码。

2. 异常处理基础回顾

在深入多异常捕获之前，我们先快速回顾一下 Java 异常处理的基本结构。

2.1 try-catch 基本结构

Java 的异常处理主要依赖 try、catch、finally 三个关键字：

try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 处理该类型异常的代码
} finally {
    // 无论是否发生异常都会执行的代码（可选）
}

2.2 异常类层次结构

Java 的异常体系以 Throwable 为根，主要分为两大分支：

• Error ：表示 JVM 层面的严重错误，如 OutOfMemoryError，通常不应捕获。
• Exception ：表示程序可以处理的异常，又分为：
  • 受检异常（Checked Exception） ：编译器强制要求处理，如 IOException、SQLException。
  • 非受检异常（Unchecked Exception） ：继承自 RuntimeException，编译器不强制处理，如 NullPointerException、ArithmeticException。

理解这个层次结构，是正确捕获多个异常的前提。

3. 捕获多个异常的三种方式

3.1 方式一：多个 catch 块（传统方式）

最直观的方式是为每种异常类型编写独立的 catch 块：

try {
    FileReader reader = new FileReader("test.txt");
    BufferedReader br = new BufferedReader(reader);
    String line = br.readLine();
    int number = Integer.parseInt(line);
    System.out.println("读取到的数字是：" + number);
} catch (FileNotFoundException e) {
    System.err.println("文件不存在：" + e.getMessage());
} catch (IOException e) {
    System.err.println("文件读取失败：" + e.getMessage());
} catch (NumberFormatException e) {
    System.err.println("文件内容不是合法数字：" + e.getMessage());
}

注意事项 ：多个 catch 块之间存在顺序关系，子类异常必须写在父类异常之前，否则编译器会报错。例如，FileNotFoundException 是 IOException 的子类，必须写在前面。

3.2 方式二：multi-catch（Java 7+）

Java 7 引入了 multi-catch 语法，允许在一个 catch 块中捕获多种不相关的异常类型，用竖线 | 分隔：

try {
    FileReader reader = new FileReader("test.txt");
    BufferedReader br = new BufferedReader(reader);
    String line = br.readLine();
    int number = Integer.parseInt(line);
    System.out.println("读取到的数字是：" + number);
} catch (FileNotFoundException | NumberFormatException e) {
    System.err.println("文件不存在或内容格式错误：" + e.getMessage());
} catch (IOException e) {
    System.err.println("文件读取失败：" + e.getMessage());
}

multi-catch 的规则：

• 竖线分隔的异常类型之间不能有继承关系（如不能写 catch (IOException | FileNotFoundException e)）。
• 异常变量 e 默认是 final 的，不能被重新赋值。
• 编译器会推断 e 的实际类型为这些异常的共同父类型。

3.3 方式三：捕获父类异常（统一处理）

如果多种异常的处理逻辑完全相同，也可以直接捕获它们的共同父类：

try {
    // 可能抛出多种异常的代码
} catch (Exception e) {
    // 统一处理所有异常
    System.err.println("发生异常：" + e.getMessage());
}

这种方式虽然简洁，但不推荐 作为默认做法，因为它会吞掉所有异常，包括 RuntimeException 和 Error，导致问题难以排查。更合理的做法是捕获具体的异常类型，或者至少区分受检异常和非受检异常。

4. 三种方式的对比与选择

对比维度	多个 catch 块	multi-catch	捕获父类异常
代码可读性	高，每种异常独立处理	中高，同类异常合并处理	低，无法区分异常类型
处理粒度	最细，可针对每种异常定制逻辑	中等，可对一组异常统一处理	最粗，所有异常同一逻辑
适用场景	各异常处理逻辑差异大	部分异常处理逻辑相同	只需记录日志或统一兜底
异常变量赋值	可以	不可以（隐式 final）	可以

选择建议：

• 各异常处理逻辑差异较大时，使用多个 catch 块。
• 部分异常处理逻辑相同时，使用 multi-catch 合并。
• 仅在确实需要统一兜底（如最外层入口）时，才捕获父类异常。

5. 进阶话题：异常屏蔽与 addSuppressed

5.1 什么是异常屏蔽

当一个 try 块中抛出异常，同时 finally 块中也抛出异常时，finally 中的异常会屏蔽 （suppress）try 中的原始异常，导致原始异常信息丢失：

try {
    throw new RuntimeException("原始异常");
} finally {
    throw new RuntimeException("finally 中的异常");
}
// 运行结果：只看到 "finally 中的异常"，原始异常被屏蔽

5.2 使用 addSuppressed 保留原始异常

Java 7 提供了 Throwable.addSuppressed() 方法，可以将被屏蔽的异常附加到主异常上：

try {
    throw new RuntimeException("原始异常");
} catch (RuntimeException e) {
    RuntimeException finallyException = new RuntimeException("finally 中的异常");
    e.addSuppressed(finallyException);
    throw e;
}

这样，原始异常和 finally 中的异常都会被保留，通过 getSuppressed() 方法可以获取被抑制的异常数组。

5.3 try-with-resources 中的异常处理

try-with-resources 语句（Java 7+）会自动处理资源关闭时的异常屏蔽问题：

try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
    String line = br.readLine();
    System.out.println(line);
} catch (IOException e) {
    // 如果 readLine() 和 close() 都抛出异常，close() 的异常会被抑制
    System.err.println("读取失败：" + e.getMessage());
    for (Throwable suppressed : e.getSuppressed()) {
        System.err.println("被抑制的异常：" + suppressed.getMessage());
    }
}

6. 实战案例：文件解析器

下面通过一个完整的实战案例，综合运用多种异常捕获方式：

import java.io.*;
import java.util.*;

public class FileNumberParser {

    public static void main(String[] args) {
        String filePath = "numbers.txt";
        try {
            List<Integer> numbers = parseNumbers(filePath);
            System.out.println("解析结果：" + numbers);
        } catch (FileNotFoundException e) {
            System.err.println("错误：文件 " + filePath + " 不存在");
        } catch (IOException e) {
            System.err.println("错误：读取文件失败 - " + e.getMessage());
        } catch (NumberFormatException e) {
            System.err.println("错误：文件包含非数字内容 - " + e.getMessage());
        }
    }

    public static List<Integer> parseNumbers(String filePath) throws IOException {
        List<Integer> numbers = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                // 每行可能包含多个逗号分隔的数字
                String[] parts = line.split(",");
                for (String part : parts) {
                    numbers.add(Integer.parseInt(part.trim()));
                }
            }
        }
        return numbers;
    }
}

在这个案例中：

• parseNumbers 方法声明抛出 IOException，由调用方处理。
• 主方法使用多个 catch 块，针对不同异常给出不同的错误提示。
• try-with-resources 确保文件流正确关闭。

7. 最佳实践总结

7.1 捕获多个异常时的注意事项

1. 不要捕获 Throwable 或 Error：这些是 JVM 层面的严重问题，程序通常无法恢复。
2. 不要空捕获 ：catch 块中至少要记录日志，否则异常被静默吞掉，问题难以排查。
3. 保持 catch 块顺序正确：子类异常在前，父类异常在后。
4. 合理使用 multi-catch：仅当处理逻辑确实相同时才合并，不要为了少写代码而强行合并。
5. 优先使用 try-with-resources ：自动管理资源关闭，避免手动 finally 中的异常屏蔽问题。

7.2 推荐的异常处理模板

try {
    // 业务代码
} catch (SpecificException1 | SpecificException2 e) {
    // 处理逻辑相同的异常
    log.error("操作失败", e);
} catch (IOException e) {
    // 单独处理 IO 异常
    log.error("IO 操作失败", e);
} finally {
    // 必要的清理工作（如非 AutoCloseable 资源）
}

8. 总结

本文详细介绍了 Java 捕获多个异常的三种方式：

• 多个 catch 块：最灵活，适合各异常处理逻辑差异大的场景。
• multi-catch：Java 7+ 语法，适合处理逻辑相同的多类异常。
• 捕获父类异常：简洁但粒度粗，仅适合统一兜底。

同时，我们还探讨了异常屏蔽、addSuppressed 和 try-with-resources 等进阶话题。掌握这些知识，能够帮助你写出更健壮、更易维护的 Java 代码。

在实际开发中，建议根据异常处理逻辑的差异程度灵活选择捕获方式，并始终遵循「捕获具体异常、记录日志、不静默吞异常」的基本原则。