引言
本文旨在帮助开发者系统掌握 Java 常见异常的排查与修复能力。通过深入分析异常体系结构、典型运行时异常及受检异常，结合堆栈解读与最佳实践，建立规范的异常处理思维。
一、Java 异常体系回顾
1.1 异常是什么？
异常（Exception） 是程序运行过程中出现的打断正常执行流程的事件。它本质上是一个对象，封装了错误类型、错误描述、方法调用堆栈以及可能的底层原因。
1.2 Java 异常体系结构
java.lang.Object | java.lang.Throwable
---------------------
| |
java.lang.Error java.lang.Exception
-------------------------
| |
RuntimeException 其他 Exception
（运行时异常） （受检异常）
- Error：JVM 级别的严重错误，如
OutOfMemoryError、StackOverflowError，程序通常无法处理。 - Exception：程序可处理的异常，分为两类：
- 受检异常（Checked Exception）：编译时必须处理（捕获或声明抛出），如
IOException、SQLException。 - 运行时异常（RuntimeException）：编译时不强制处理，通常由程序逻辑错误导致，如
NullPointerException、ArrayIndexOutOfBoundsException。
- 受检异常（Checked Exception）：编译时必须处理（捕获或声明抛出），如
1.3 异常信息解读
一个典型的异常堆栈包含以下要素：
Exception java.lang.IllegalArgumentException: item quantity must be a number at io.jzheaux.pluralsight.DeliController.orderSandwich (DeliController.java:45) // … Caused by java.lang.NumberFormatException: For input string: " 3" at NumberFormatException.forInputString (NumberFormatException.java:67) at Integer.parseInt (Integer.java:647) ...
- 异常类型：
IllegalArgumentException - 异常消息：
item quantity must be a number - 堆栈轨迹：从 main 开始到异常发生处的调用链
- Caused by：底层根本原因，通常是排查的关键入口
排查技巧：遇到复杂异常时，不要只看第一行，要顺着堆栈往下找，尤其是'Caused by'部分，那里往往藏着真正的原因。
二、常见运行时异常深度剖析
运行时异常（RuntimeException）是 Java 程序中最常见的异常类型，它们通常由代码逻辑错误引起。下面我们将逐个剖析最常见的运行时异常。
2.1 NullPointerException（空指针异常）
现象描述
当应用程序试图在需要对象的地方使用 null 引用时，抛出此异常。这是 Java 中最著名的异常，占据了异常总数的很大比例。
出现场景
场景一：直接调用 null 对象的方法或属性
String text = null;
int length = text.length(); // 抛出 NullPointerException
场景二：自动拆箱时包装类型为 null
Boolean willVote = null;
if (willVote) { // 自动拆箱时抛出 NullPointerException
System.out.println("可以投票");
}
场景三：方法参数或返回值未做空检查
void parseDocument(Document doc) {
doc.getElements(); // 如果传入的 doc 为 null，抛出异常
}
String lookupElement(Document doc) {
Element element = doc.findElement("span");
return element.getValue(); // 如果 element 为 null，抛出异常
}
场景四：数组元素未初始化
Person[] people = new Person[5];
people[0].getName(); // 数组元素默认为 null，抛出异常
堆栈分析示例
Exception in thread "main" java.lang.NullPointerException
at com.example.UserService.getUserAge(UserService.java:25)
at com.example.UserController.main(UserController.java:12)
从堆栈可以看出，UserService.java的第 25 行调用了某个 null 对象的方法。
排查方法流程图
方法参数 → 方法返回值 → 未初始化变量 → 数组元素 → 发现 NullPointerException → 定位堆栈中第一个出现自己代码的行号 → 检查该行代码有哪些对象可能为 null → 对象来源是什么？ → 检查调用方是否传入 null / 检查被调用方法是否可能返回 null / 检查变量是否已正确初始化 / 检查数组元素是否已赋值 → 修复调用方或添加空值校验
代码修正与预防
修正方案一：参数校验
// 错误代码
void parseDocument(Document doc) {
doc.getElements();
}
// 修正代码
void parseDocument(@NonNull Document doc) {
if (doc == null) {
throw new IllegalArgumentException("doc cannot be null");
}
doc.getElements();
}
修正方案二：使用守卫语句
// 错误代码
String lookupElement(Document doc) {
Element element = doc.findElement("span");
return element.getValue();
}
// 修正代码
@Nullable String lookupElement(Document doc) {
Element element = doc.findElement("span");
if (element == null) {
return null; // 或者返回默认值
}
return element.getValue();
}
修正方案三：使用 Optional（Java 8+）
public Optional<String> lookupElement(Document doc) {
return Optional.ofNullable(doc.findElement("span")).map(Element::getValue);
}
修正方案四：数组元素初始化
Person[] people = new Person[5];
for (int i = 0; i < people.length; i++) {
people[i] = new Person(); // 确保每个元素都被初始化
}
预防措施：
- 明确空值来源：是无效值（上游问题）还是有效值（可接受 null）
- 使用@NonNull 和@Nullable 注解，让 IDE 帮助检查
- 遵循"尽早失败"原则：在方法入口处就进行参数校验
- 谨慎处理返回值：明确方法是否可能返回 null，并在文档中说明
2.2 ArrayIndexOutOfBoundsException（数组下标越界异常）
现象描述
当试图使用非法索引访问数组元素时抛出，非法索引包括负数、0 到数组长度减 1 范围外的值。
出现场景
场景一：索引超出数组长度
int[] numbers = {1, 2, 3};
int value = numbers[3]; // 索引 3 超出范围（有效索引 0-2）
场景二：循环条件错误
int[] scores = {85, 90, 78, 92};
for (int i = 0; i <= scores.length; i++) { // 应该是 i < scores.length
System.out.println(scores[i]); // 最后一次循环 i=4，越界
}
场景三：索引为负数
int[] data = new int[10];
int index = -1;
data[index] = 100; // 负索引越界
堆栈分析示例
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
at com.example.ArrayDemo.processArray(ArrayDemo.java:15)
at com.example.ArrayDemo.main(ArrayDemo.java:8)
异常信息直接告诉我们：试图访问索引 5，但数组长度只有 5（有效索引 0-4）。
排查方法
直接常量 → 循环变量 → 计算结果 → 发现 ArrayIndexOutOfBoundsException → 定位堆栈中的代码行 → 检查该行代码的数组访问表达式 → 索引值是如何计算的？ → 检查常量是否在合法范围内 / 检查循环条件边界 / 检查计算逻辑是否有误 → 修正索引值
代码修正与预防
修正方案一：修正循环边界
// 错误代码
for (int i = 0; i <= scores.length; i++) {
System.out.println(scores[i]);
}
// 修正代码
for (int i = 0; i < scores.length; i++) {
System.out.println(scores[i]);
}
// 更好的方式：使用增强 for 循环
for (int score : scores) {
System.out.println(score);
}
修正方案二：访问前检查索引
public int getElement(int[] array, int index) {
if (array == null) {
throw new IllegalArgumentException("array cannot be null");
}
if (index < 0 || index >= array.length) {
throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length " + array.length);
}
return array[index];
}
预防措施：
- 优先使用增强 for 循环处理数组遍历
- 使用 Arrays 工具类的方法进行数组操作
- 动态计算索引时，添加边界检查
- 考虑使用 ArrayList等集合类，它们提供了更安全的 get() 方法（也会抛出越界异常，但信息更明确）
2.3 ClassCastException（类型转换异常）
现象描述
当试图将一个对象强制转换为它不是实例的子类时抛出。这是使用继承和多态时的常见问题。
出现场景
场景一：将父类对象强制转换为子类类型
Object obj = new Object();
Integer num = (Integer) obj; // Object 不能转换为 Integer
场景二：集合中元素类型不一致
List list = new ArrayList();
list.add("Hello");
list.add(123); // 混合类型
String first = (String) list.get(0); // 正常
String second = (String) list.get(1); // 抛出 ClassCastException，123 不能转 String
场景三：不正确的向下转型
Animal animal = new Dog();
Cat cat = (Cat) animal; // Dog 不能转换为 Cat
堆栈分析示例
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String
at com.example.GenericDemo.processList(GenericDemo.java:22)
at com.example.GenericDemo.main(GenericDemo.java:15)
异常信息明确告诉我们：试图将 Integer 转换为 String，类型不兼容。
排查方法
集合 → 方法返回值 → 从外部系统获取 → 发现 ClassCastException → 定位堆栈中的转换代码行 → 检查被转换对象的实际类型 → 对象来源是什么？ → 检查集合中元素类型是否一致 / 检查返回类型的实际实现 / 检查序列化/反序列化过程 → 使用泛型或 instanceof 检查
代码修正与预防
修正方案一：使用泛型
// 错误代码
List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0);
// 修正代码：使用泛型
List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0); // 无需强制转换
修正方案二：使用 instanceof 检查
Object obj = getSomeObject();
if (obj instanceof String) {
String str = (String) obj; // 安全转换
// 处理字符串
} else if (obj instanceof Integer) {
Integer num = (Integer) obj; // 安全转换
// 处理整数
}
修正方案三：Java 16+ 的 Pattern Matching for instanceof
Object obj = getSomeObject();
if (obj instanceof String str) { // 这里可以直接使用 str 变量
System.out.println(str.length());
} else if (obj instanceof Integer num) {
System.out.println(num + 10);
} else {
// 处理其他情况
}
预防措施：
- 始终使用泛型确保集合类型安全
- 在向下转型前使用 instanceof 检查
- 遵循里氏替换原则，避免不必要的向下转型
- 考虑使用多态，而不是频繁的类型转换
2.4 ArithmeticException（算术异常）
现象描述
当发生异常的算术条件时抛出，最常见的是整数除零。
出现场景
场景一：整数除零
int result = 10 / 0; // 抛出 ArithmeticException
场景二：取模运算除零
int remainder = 10 % 0; // 抛出 ArithmeticException
注意：浮点数除零不会抛出异常，会返回 Infinity 或 NaN
double result = 10.0 / 0.0; // 返回 Infinity，不会抛出异常
堆栈分析示例
Exception in thread "main" java.lang.ArithmeticException: / by zero
at com.example.Calculator.divide(Calculator.java:10)
at com.example.Calculator.main(Calculator.java:5)
异常信息直接告诉我们问题：除零。
排查方法
直接常量 → 变量 → 方法返回值 → 发现 ArithmeticException → 定位堆栈中的除法/取模代码 → 检查分母/右操作数的值 → 分母来源是什么？ → 修改常量为非零值 / 检查变量赋值逻辑 / 检查返回值的范围 → 添加除零检查
代码修正与预防
修正方案一：检查除数
public int divide(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("除数不能为 0");
}
return a / b;
}
修正方案二：使用 Optional 处理可能为 0 的情况
public Optional<Integer> safeDivide(int a, int b) {
if (b == 0) {
return Optional.empty();
}
return Optional.of(a / b);
}
修正方案三：使用浮点数运算（如果业务允许）
double result = 10.0 / 0.0; // 返回 Infinity，不会抛出异常
if (Double.isInfinite(result)) {
// 处理无穷大情况
}
预防措施：
- 在进行除法或取模前，始终检查除数是否为 0
- 考虑使用 BigDecimal进行精确计算，它提供了更好的异常处理
- 从用户输入获取除数时，必须进行验证
三、其他运行时异常与受检异常
3.1 NumberFormatException（数字格式异常）
现象描述
当尝试将字符串转换为数字类型，但字符串格式不合法时抛出。
出现场景
场景一：字符串包含非数字字符
int num = Integer.parseInt("123abc"); // 抛出 NumberFormatException
场景二：字符串包含空格或特殊符号
int num = Integer.parseInt(" 123 "); // 抛出 NumberFormatException，空格未处理
场景三：数字超出类型范围
int num = Integer.parseInt("2147483648"); // 超出 int 最大值，抛出异常
场景四：空字符串或 null
int num = Integer.parseInt(""); // 抛出 NumberFormatException
Integer.parseInt(null); // 抛出 NullPointerException，注意这里是 NPE
堆栈分析示例
Exception in thread "main" java.lang.NumberFormatException: For input string: " 123 "
at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
at java.base/java.lang.Integer.parseInt(Integer.java:654)
at java.base/java.lang.Integer.parseInt(Integer.java:786)
at com.example.UserInput.processAge(UserInput.java:12)
排查方法
graph TD
A[开始] --> B{输入是否为 null?}
B -- 是 --> C[抛出 NullPointerException]
B -- 否 --> D{去除前后空格}
D --> E{是否为空?}
E -- 是 --> F[抛出 NumberFormatException]
E -- 否 --> G{匹配正则 \d+?}
G -- 否 --> H[抛出 NumberFormatException]
G -- 是 --> I[成功解析]
代码修正与预防
修正方案一：数据清洗
// 错误代码
String input = " 123 ";
int value = Integer.parseInt(input); // 抛出异常
// 修正代码
String input = " 123 ";
input = input.trim(); // 去除前后空格
if (!input.isEmpty()) {
try {
int value = Integer.parseInt(input);
} catch (NumberFormatException e) {
// 处理异常
}
}
修正方案二：使用正则表达式预验证
public int parsePostalCode(String input) {
// 预验证：必须是 5 位数字
if (input == null || !input.matches("\\d{5}")) {
throw new IllegalArgumentException("邮政编码必须是 5 位数字");
}
return Integer.parseInt(input); // 此时已保证安全
}
修正方案三：使用 Apache Commons Lang 的 NumberUtils
import org.apache.commons.lang3.math.NumberUtils;
String input = "123";
int value = NumberUtils.toInt(input, 0); // 失败时返回默认值 0，不抛出异常
修正方案四：Java 8+ 的 Optional + 异常处理
public Optional<Integer> tryParseInt(String input) {
try {
return Optional.of(Integer.parseInt(input.trim()));
} catch (NumberFormatException e) {
return Optional.empty();
}
}
预防措施：
- 始终对输入进行清洗（trim、去除非数字字符）
- 解析前验证格式，特别是来自外部系统的数据
- 考虑使用专门的验证框架如 Hibernate Validator
- 使用 try-catch 包围解析代码，优雅处理异常
3.2 IllegalArgumentException（非法参数异常）
现象描述
当向方法传递了不合法或不适当的参数时抛出。这通常表示调用者的责任。
出现场景
场景一：参数值超出允许范围
public void setAge(int age) {
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄必须在 0-150 之间");
}
this.age = age;
}
场景二：参数格式错误
public void setEmail(String email) {
if (email == null || !email.contains("@")) {
throw new IllegalArgumentException("邮箱格式不正确");
}
this.email = email;
}
场景三：参数为 null 但方法不允许
public void processData(@NonNull Data data) {
if (data == null) {
throw new IllegalArgumentException("data cannot be null");
}
// 处理数据
}
排查方法
- 查看异常消息，通常会说明参数需要满足什么条件
- 检查调用代码，确认传入的参数值
- 验证参数来源，判断是输入错误还是上游数据问题
代码修正
// 在方法开头进行参数校验
public void registerUser(String username, String email, int age) {
// 参数校验集中处理
if (username == null || username.trim().isEmpty()) {
throw new IllegalArgumentException("用户名不能为空");
}
if (email == null || !email.matches("^[A-Za-z0-9+_.-]+@(.+)$")) {
throw new IllegalArgumentException("邮箱格式不正确");
}
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄无效");
}
// 业务逻辑
}
3.3 IllegalStateException（非法状态异常）
现象描述
当方法在非法或不适当的时间被调用时抛出。通常表示被调用者的状态不适合执行请求的操作。
出现场景
场景一：对象未正确初始化
public class ConnectionPool {
private boolean initialized = false;
public void connect() {
if (!initialized) {
throw new IllegalStateException("连接池未初始化");
}
// 建立连接
}
}
场景二：迭代器越界
List<String> list = Arrays.asList("A", "B");
Iterator<String> it = list.iterator();
it.next(); // A
it.next(); // B
it.next(); // 抛出 NoSuchElementException，但有时会被包装为 IllegalStateException
排查方法
- 阅读异常消息，了解当前对象应该处于什么状态
- 检查对象初始化或配置代码，确保在调用前已正确设置
- 检查操作顺序，确认是否按正确步骤调用
代码修正
public class FileProcessor {
private boolean opened = false;
public void open() {
// 打开文件
opened = true;
}
public void readData() {
if (!opened) {
throw new IllegalStateException("必须先调用 open() 方法打开文件");
}
// 读取数据
}
}
3.4 IOException（输入输出异常）
现象描述
当输入输出操作失败或中断时抛出。这是最典型的受检异常，处理文件、网络、流操作时经常遇到。
出现场景
场景一：文件不存在（FileNotFoundException）
FileReader fr = new FileReader("nonexistent.txt"); // 抛出 FileNotFoundException
场景二：读取流时连接断开
InputStream in = socket.getInputStream();
int data = in.read(); // 如果连接已关闭，可能抛出 IOException
场景三：写入磁盘空间不足
FileOutputStream fos = new FileOutputStream("largefile.bin");
byte[] data = new byte[1024];
fos.write(data); // 如果磁盘空间不足，抛出 IOException
堆栈分析示例
java.io.FileNotFoundException: nonexistent.txt (系统找不到指定的文件)
at java.base/java.io.FileInputStream.open0(Native Method)
at java.base/java.io.FileInputStream.open(FileInputStream.java:219)
at java.base/java.io.FileInputStream.<init>(FileInputStream.java:157)
at com.example.FileReaderDemo.main(FileReaderDemo.java:8)
排查方法
FileNotFoundException → EOFException → SocketException → 其他 IO 错误 → 发现 IOException → 查看异常消息中的具体原因 → 原因类型？ → 检查文件路径和存在性 / 检查是否提前到达文件末尾 / 检查网络连接状态 / 检查磁盘空间、权限等 → 修正路径或创建文件
代码修正与预防
修正方案一：使用 try-with-resources 确保资源关闭
// 错误代码：可能忘记关闭资源
public String readFile(String path) throws IOException {
FileReader fr = new FileReader(path);
BufferedReader br = new BufferedReader(fr);
return br.readLine(); // 没有关闭资源，可能造成内存泄漏
}
// 修正代码：使用 try-with-resources
public String readFile(String path) throws IOException {
try (FileReader fr = new FileReader(path);
BufferedReader br = new BufferedReader(fr)) {
return br.readLine(); // 自动关闭
}
}
修正方案二：检查文件存在性
public void processFile(String path) {
File file = new File(path);
if (!file.exists()) {
System.err.println("文件不存在：" + path);
return; // 或者抛出更友好的异常
}
try (BufferedReader br = new BufferedReader(new FileReader(file))) {
// 处理文件
} catch (IOException e) {
System.err.println("读取文件时发生错误：" + e.getMessage());
e.printStackTrace();
}
}
修正方案三：多层异常处理
public void copyFile(String src, String dest) {
try (FileInputStream in = new FileInputStream(src);
FileOutputStream out = new FileOutputStream(dest)) {
byte[] buffer = new byte[1024];
int length;
while ((length = in.read(buffer)) > 0) {
out.write(buffer, 0, length);
}
} catch (FileNotFoundException e) {
System.err.println("源文件不存在或目标目录无法写入：" + e.getMessage());
} catch (IOException e) {
System.err.println("复制过程中发生 IO 错误：" + e.getMessage());
}
}
预防措施：
- 始终使用 try-with-resources或确保 finally 中关闭资源
- 操作前检查文件和目录状态
- 为 IO 操作提供有意义的错误消息
- 考虑重试机制，特别是网络相关的 IO 操作
3.5 ClassNotFoundException（类未找到异常）
现象描述
当应用程序试图通过字符串名加载类，但在类路径中找不到该类的定义时抛出。
出现场景
场景一：Class.forName() 加载类
Class.forName("com.mysql.jdbc.Driver"); // 如果驱动 jar 不在类路径中，抛出异常
场景二：类加载器加载类
ClassLoader.getSystemClassLoader().loadClass("com.example.MissingClass");
场景三：使用反射创建实例
Object obj = Class.forName("com.example.DynamicClass").newInstance();
堆栈分析示例
java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
at java.base/java.net.URLClassLoader.findClass(URLClassLoader.java:476)
at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:589)
at java.base/java.lang.Class.forName0(Native Method)
at java.base/java.lang.Class.forName(Class.java:398)
排查方法
是 → 否 → 发现 ClassNotFoundException → 查看缺少的类名 → 确认该类属于哪个库/JAR → 该类是否应该存在？ → 检查类路径配置 → 检查类名拼写或版本兼容性 → 添加缺失的 JAR 到类路径
代码修正与预防
修正方案一：确保 JAR 包在类路径中
- 对于 Maven 项目：检查 pom.xml 中的依赖
- 对于普通项目：确认 JAR 文件在 classpath 下
修正方案二：捕获并处理异常
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// 提供友好的错误信息
throw new RuntimeException("MySQL 驱动未找到，请检查是否添加了 mysql-connector-java 依赖", e);
}
修正方案三：使用 ServiceLoader 模式（Java 6+）
ServiceLoader<Driver> drivers = ServiceLoader.load(Driver.class);
for (Driver driver : drivers) {
// 自动发现所有驱动实现
}
四、综合实战与最佳实践
4.1 复杂异常排查案例
案例：银行转账系统中的异常链
public class BankingService {
public void transfer(String fromAccount, String toAccount, double amount) throws BusinessException {
try {
Account from = accountRepository.findByNumber(fromAccount);
Account to = accountRepository.findByNumber(toAccount);
if (from == null || to == null) {
throw new IllegalArgumentException("账户不存在");
}
from.withdraw(amount);
to.deposit(amount);
transactionLog.log(fromAccount, toAccount, amount);
} catch (IllegalArgumentException e) {
throw new BusinessException("转账参数错误", e);
} catch (InsufficientBalanceException e) {
throw new BusinessException("余额不足", e);
} catch (Exception e) {
throw new BusinessException("转账失败，请稍后重试", e);
}
}
}
异常排查思路
当看到类似下面的异常堆栈时：
com.example.BusinessException: 转账失败，请稍后重试
at com.example.BankingService.transfer(BankingService.java:45)
at com.example.BankingController.main(BankingController.java:18)
Caused by: java.sql.SQLException: Connection timed out
at com.mysql.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:2189)
at com.mysql.jdbc.ConnectionImpl.<init>(ConnectionImpl.java:795)
at com.mysql.jdbc.NonRegisteringDriver.connect(NonRegisteringDriver.java:329)
at java.sql(DriverManager.:)
(AccountRepository.:)
...
排查步骤：
- 看顶层异常：
BusinessException，但消息太泛化，请稍后重试没有实质信息 - 看 Caused by：
SQLException: Connection timed out，这才是真正原因 - 追溯源头：
AccountRepository.java:22处的数据库连接超时 - 根本原因：数据库连接失败
解决方案：
- 检查数据库服务是否运行
- 检查网络连接
- 检查数据库连接池配置
- 添加重试机制
教训：包装异常时不要丢失原始信息，提供具体的错误消息有助于排查。
4.2 异常处理最佳实践总结
4.2.1 捕获特定异常，而不是通用异常
// 不好的做法
try {
// 业务代码
} catch (Exception e) {
// 捕获所有异常，掩盖了真正的问题
}
// 好的做法
try {
// 业务代码
} catch (FileNotFoundException e) {
// 处理文件不存在
} catch (IOException e) {
// 处理其他 IO 错误
}
4.2.2 避免空的 catch 块
// 绝对不要这样做
try {
riskyOperation();
} catch (Exception e) {
// 空的 catch 块，异常被吞噬
}
// 至少记录异常
try {
riskyOperation();
} catch (Exception e) {
logger.error("操作失败", e); // 记录日志
throw e; // 或者重新抛出
}
4.2.3 使用 try-with-resources 自动关闭资源
// Java 7 之前的方式
FileInputStream fis = null;
try {
fis = new FileInputStream("file.txt"); // 处理文件
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// Java 7+ 推荐的方式
try (FileInputStream fis = new FileInputStream("file.txt")) {
// 处理文件
} // 自动关闭
4.2.4 使用自定义异常增强业务语义
// 自定义业务异常
public class InsufficientBalanceException extends Exception {
private double currentBalance;
private double requiredAmount;
public InsufficientBalanceException(double current, double required) {
super(String.format("余额不足：当前余额%.2f，需要%.2f", current, required));
this.currentBalance = current;
this.requiredAmount = required;
}
// getters...
}
// 使用
public void withdraw(double amount) throws InsufficientBalanceException {
if (balance < amount) {
throw new InsufficientBalanceException(balance, amount);
}
balance -= amount;
}
4.2.5 方法重写时遵守异常声明规则
- 子类方法可以抛出与父类相同的异常、子类异常，或不抛出异常
- 子类方法不能抛出比父类更宽泛的受检异常
class Parent {
public void process() throws IOException {}
}
class Child extends Parent {
@Override
public void process() throws FileNotFoundException {} // 允许，FileNotFoundException 是 IOException 的子类
// @Override
// public void process() throws Exception { } // 不允许，Exception 比 IOException 更宽泛
}
4.2.6 记录异常时包含上下文信息
try {
processOrder(orderId, userId);
} catch (OrderException e) {
// 记录有用的上下文信息
logger.error("处理订单失败：orderId={}, userId={}", orderId, userId, e);
throw e;
}
4.2.7 不要用异常控制正常的程序流程
// 不好的做法：用异常控制流程
try {
Integer.parseInt(userInput); // 是数字，继续处理
} catch (NumberFormatException e) {
// 不是数字，执行其他逻辑
}
// 好的做法：使用条件判断
if (userInput.matches("\\d+")) {
int value = Integer.parseInt(userInput); // 是数字，继续处理
} else {
// 不是数字，执行其他逻辑
}
4.2.8 异常处理的黄金法则总结
| 原则 | 说明 |
|---|---|
| 精准捕获 | 捕获具体的异常类型，而不是笼统的 Exception |
| 绝不吞噬 | 空的 catch 块是万恶之源，至少要记录日志 |
| 及时释放 | 使用 try-with-resources 或 finally 确保资源释放 |
| 保留原始异常 | 包装异常时要把原异常作为 cause 传入 |
| 提供上下文 | 异常消息要包含有助于排查的信息 |
| 区分异常类型 | 可恢复用受检异常，程序错误用运行时异常 |
| 文档化 | 用 javadoc 的@throws 说明方法可能抛出的异常 |
4.3 Java 7+ 多异常捕获
从 Java 7 开始，可以使用 | 在一个 catch 块中捕获多个异常类型，减少代码重复：
try {
// 可能抛出多种异常的代码
} catch (IOException | SQLException e) {
// 统一处理 IO 和 SQL 异常
logger.error("数据访问错误", e);
throw e; // Java 7+ 支持更精确的重抛类型检查
}
注意：多异常捕获时，catch 参数隐式为 final，不能修改。
4.4 异常处理与事务管理
在企业级应用中，异常处理与事务管理密切相关。通常：
- 运行时异常触发事务回滚
- 受检异常不自动触发事务回滚（在 Spring 中可通过 rollbackFor 配置）
@Service
public class AccountService {
@Transactional(rollbackFor = {BusinessException.class, RuntimeException.class})
public void transferMoney(String from, String to, double amount) throws BusinessException {
try {
// 转账逻辑
} catch (InsufficientBalanceException e) {
// 业务异常，触发事务回滚
throw new BusinessException("转账失败", e);
}
}
}
五、总结
知识体系回顾
通过本文的学习，我们全面覆盖了：
- 异常基础：体系结构、受检与非受检异常、异常信息解读
- 运行时异常：
NullPointerException：空引用访问 → 前置检查、OptionalArrayIndexOutOfBoundsException：数组越界 → 边界检查、增强 for 循环ClassCastException：类型转换错误 → instanceof 检查、泛型ArithmeticException：算术异常 → 除零检查NumberFormatException：数字格式错误 → 输入清洗、预验证IllegalArgumentException/IllegalStateException：参数/状态错误 → 前置校验
- 受检异常：
IOException及其子类 → try-with-resources、文件存在性检查ClassNotFoundException→ 检查类路径、依赖管理
- 排查方法：堆栈分析、Caused by 追踪、异常链理解
- 最佳实践：精准捕获、避免吞噬、及时释放、保留上下文等 8 大原则
异常排查思维导图
graph TD
A[遇到异常] --> B{1. 看类型：是什么异常？}
B --> C{2. 看消息：说了什么？}
C --> D{3. 看堆栈：第一行在哪？}
D --> E{4. 看原因：有 Caused by?}
E --> F{5. 想来源：值从哪来？}
F --> G{6. 想方案：怎么修复？}
G --> H[结束]
