在 Java 程序运行过程中，任何非预期的事件都可能导致程序流程中断，这些事件被称为异常。Java 提供了一套强大的异常处理机制，通过将异常对象化，允许程序在遇到问题时进行捕获、处理或重新抛出，从而避免程序意外崩溃。

异常的分类

• Error (错误): 这类问题通常是 JVM 内部的严重错误，例如内存耗尽（OutOfMemoryError）或栈溢出（StackOverflowError）。程序对此类错误无能为力，通常也无需捕获。
• Exception (异常): 这是程序中可以预期并处理的错误。它进一步分为两类：
  • 受检异常 (Checked Exception): 编译器在编译阶段强制要求处理。如果一个方法可能抛出受检异常，它必须通过 `try-catch` 块进行捕获，或者在方法签名中使用 `throws` 关键字声明将异常抛给调用者。常见的受检异常包括文件 I/O 操作异常、网络异常以及自定义的业务逻辑异常。
  • 非受检异常 (Unchecked Exception): 也称为运行时异常（RuntimeException）。这类异常在程序运行时才可能出现，编译器不强制要求捕获。常见的非受检异常包括空指针引用（NullPointerException）、数组索引越界（ArrayIndexOutOfBoundsException）以及数据类型转换错误（ClassCastException）等。

核心语法：try-catch-finally

Java 提供了 `try-catch-finally` 结构来处理异常：

try {
    // 包含可能引发异常的代码块
} catch (ExceptionType1 e1) {
    // 捕获并处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {
    // 捕获并处理 ExceptionType2 类型的异常
} finally {
    // 无论是否发生异常，此代码块中的语句总是会被执行，
    // 常用于资源清理，如关闭文件流或网络连接。
}
    

示例：文件读取中的 IO 异常处理

BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("data.csv"));
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每一行数据
    }
} catch (FileNotFoundException e) {
    System.err.println("错误：指定的数据文件未找到。");
    // 可以选择记录日志或抛出自定义异常
} catch (IOException e) {
    System.err.println("读取文件时发生 IO 错误：" + e.getMessage());
    // 记录日志或抛出自定义异常
} finally {
    if (reader != null) {
        try {
            reader.close(); // 确保流被关闭
        } catch (IOException e) {
            System.err.println("关闭文件流时发生错误：" + e.getMessage());
        }
    }
}
    

throws 关键字：声明异常

当一个方法内部无法处理某个异常，或者希望将异常处理的责任交给调用者时，可以使用 `throws` 关键字在方法签名中声明可能抛出的异常。这通常用于处理受检异常。

import java.util.List;

// 假设存在一个自定义的业务异常类 GradeSystemException
public List<Student> loadStudents(String filePath) throws GradeSystemException, IOException {
    // ... 文件读取和解析逻辑 ...
    // 如果发生自定义业务异常或 IO 异常，则抛出
    if (/* 发生特定错误 */) {
        throw new GradeSystemException("处理学生数据时发生错误");
    }
    // ... 返回学生列表 ...
    return studentList;
}
    

throw 关键字：手动抛出异常

`throw` 关键字用于在代码的任何位置主动创建一个异常对象并抛出。这常用于进行业务规则校验，例如当输入数据不符合要求时。

// 假设 parts 是从某行文本分割得到的字符串数组
if (parts.length != 3) {
    throw new IllegalArgumentException("错误：第 " + lineNumber + " 行数据格式不正确，期望 3 个字段，实际 " + parts.length + " 个。");
}
// ... 继续处理解析后的数据 ...
    

自定义异常：增强错误信息

创建自定义异常类是 Java 异常处理中的一个重要实践，它能提供更精确的错误描述，并帮助组织不同类型的业务错误。

设计思路

1. 创建一个顶层业务异常类，例如 `ApplicationException`，它通常继承自 `Exception`（表示受检异常）。
2. 根据具体的业务场景，创建该顶层异常的子类，以区分不同类型的业务错误，如 `FileProcessingException`、`DataValidationException`、`PermissionDeniedException` 等。
3. 在自定义异常的构造方法中，接受一个 `Throwable cause` 参数，用于封装原始的底层异常。这实现了异常链，保留了完整的错误堆栈信息。

基类示例：ApplicationException

// 自定义的顶层应用异常，继承自 Exception，使其成为受检异常
public class ApplicationException extends Exception {

    public ApplicationException(String message) {
        super(message);
    }

    // 构造方法，用于封装原始异常，形成异常链
    public ApplicationException(String message, Throwable cause) {
        super(message, cause);
    }
}
    

子类示例：FileFormatException

// 文件格式相关的异常，继承自 ApplicationException
public class FileFormatException extends ApplicationException {

    public FileFormatException(String message) {
        super(message);
    }

    public FileFormatException(String message, Throwable cause) {
        super(message, cause);
    }
}
    

异常链：追踪根本原因

异常链允许我们将底层的、技术性的异常（如 `IOException`、`SQLException`）包装到更具业务意义的自定义异常中。在包装时，将原始异常作为参数传递给自定义异常的构造方法，从而保留了完整的堆栈跟踪信息。

例如，在读取文件时，如果发生 `IOException`，可以将其封装为 `FileAccessException`，并保留原始的 `IOException` 作为异常链的 `cause`。

FileInputStream fis = null;
try {
    fis = new FileInputStream("config.properties");
    // ... 读取配置文件 ...
} catch (IOException e) {
    // 将底层的 IOException 封装为自定义的 FileAccessException，并传入原始异常 e
    throw new FileAccessException("无法访问或读取配置文件", e);
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            // 处理关闭流时可能发生的异常
        }
    }
}
    

通过调用异常对象的 `printStackTrace()` 方法，可以打印出完整的异常堆栈，包括所有封装的底层异常，这对于快速定位问题根源至关重要。

try-with-resources：自动资源管理

Java 7 引入了 `try-with-resources` 语句，它能够自动管理实现了 `AutoCloseable` 接口的资源（如文件流、数据库连接等）。在 `try` 块结束时（无论是否发生异常），这些资源都会被自动关闭，无需显式编写 `finally` 块来调用 `close()` 方法，极大地简化了代码并减少了资源泄漏的风险。

// 使用 try-with-resources 自动关闭 ObjectInputStream
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user_data.dat"))) {
    // 反序列化数据
    List<User> users = (List<User>) ois.readObject();
    // ... 处理反序列化的用户列表 ...
} catch (IOException e) {
    // 包装为自定义异常，并包含原始异常
    throw new DataStorageException("反序列化用户数据失败", e);
} catch (ClassNotFoundException e) {
    // 包装为自定义异常，并包含原始异常
    throw new DataStorageException("反序列化时找不到类定义", e);
}
    

序列化相关的异常处理

在进行 Java 对象序列化和反序列化时，可能会遇到一些特定的异常：

• `java.io.InvalidClassException`: 通常由于 `serialVersionUID` 不匹配导致，表明类的版本发生了变化，不兼容。
• `java.lang.ClassNotFoundException`: 在反序列化时，如果 JVM 找不到对应的类定义，就会抛出此异常。

这些异常通常也应该被捕获并封装到自定义的业务异常中，以便提供更友好的错误信息。

try {
    Object obj = ois.readObject(); // 尝试读取序列化对象
    // ...
} catch (ClassNotFoundException e) {
    // 封装为自定义异常，说明类版本不兼容
    throw new DataSerializationException("序列化数据中包含的类版本不兼容或已更改", e);
} catch (InvalidClassException e) {
    // 封装为自定义异常，说明类版本号不匹配
    throw new DataSerializationException("序列化类版本号 (serialVersionUID) 不匹配", e);
}
    

生产环境中的异常处理规范

1. 分层捕获与处理: 区分并捕获不同类型的异常（如文件错误、数据格式错误、权限问题），提供清晰、准确的错误信息。
2. 避免吞噬异常: 绝不允许出现空的 `catch` 块。至少应该记录异常日志，或者将异常向上抛出。
3. 维护异常链: 对于捕获到的底层异常，应将其作为 `cause` 传入自定义异常的构造方法，保留完整的堆栈信息，便于调试。
4. 保证程序健壮性: 对于可恢复的错误（如 CSV 文件中某一行数据格式错误），应采取容错措施（如跳过该行），而不是直接终止整个程序的执行。
5. 全面覆盖异常场景: 确保能够处理各种潜在的异常情况，包括但不限于文件不存在、文件编码错误、权限不足、类版本不匹配、数据脏乱、空文件等。

常见误区

• 过度使用 `catch (Exception e)`: 捕获过于宽泛的异常类型会掩盖不同错误的本质，不利于精确诊断。
• 在 `finally` 块中使用 `return`: `finally` 块中的 `return` 语句会覆盖 `try` 或 `catch` 块中的 `return` 语句，并可能导致异常信息丢失。
• 仅打印 `e.getMessage()`: `e.getMessage()` 只提供异常的简短描述，调试时必须使用 `e.printStackTrace()` 来查看完整的堆栈跟踪信息。
• 自定义业务异常设计不当: 应该优先设计为受检异常，以强制调用者处理可能的数据处理失败等业务逻辑异常。