文章目录
引言
大家好！今天我们来聊一个Java开发中绕不开的话题——异常处理！！！作为一名开发者，你肯定遇到过那种程序突然崩溃，控制台疯狂输出红色错误信息的情况。没错，那就是异常在"作怪"。
异常处理可能不是编程中最性感的部分，但它绝对是最重要的技能之一（没有之一）。掌握了它，你就能写出更加健壮的代码，让用户体验更流畅，也让自己少掉几根头发。
接下来，我们将深入探讨Java异常的方方面面，从基础概念到高级技巧，一起成为异常处理的大师！
什么是Java异常？
简单来说，异常是程序运行过程中出现的意外情况。当Java虚拟机遇到无法正常处理的情况时，就会创建一个异常对象，并将其"抛出"。
举个栗子，假设你写了一段代码，想要读取一个文件，但这个文件不存在，这时候JVM就会抛出FileNotFoundException。如果没有适当的处理机制，程序就会崩溃，用户看到一堆莫名其妙的错误信息。
Java异常体系结构
Java异常体系是个层次分明的家族树，顶层是Throwable类，下面分为两大分支：
-
Error：表示严重的问题，通常是系统级别的，应用程序通常无法恢复。比如
OutOfMemoryError、StackOverflowError等。 -
Exception：表示可以被程序处理的异常情况。又分为两类：
- 受检异常(Checked Exception)：编译器强制要求处理的异常，如
IOException、SQLException等。 - 非受检异常(Unchecked Exception)：编译器不强制要求处理的异常，主要是
RuntimeException及其子类，如NullPointerException、ArrayIndexOutOfBoundsException等。
- 受检异常(Checked Exception)：编译器强制要求处理的异常，如
画个简单的"家谱图"：
Throwable
├── Error (系统级错误，程序通常无法恢复)
└── Exception
├── RuntimeException (非受检异常)
│ ├── NullPointerException
│ ├── ArrayIndexOutOfBoundsException
│ └── ...
└── 其他Exception (受检异常)
├── IOException
├── SQLException
└── ...
常见的Java异常类型
现在让我们看看日常编码中最容易遇到的几种异常：
-
NullPointerException：空指针异常，试图访问null对象的方法或属性时抛出。
String str = null; int length = str.length(); // 轰！NullPointerException -
ArrayIndexOutOfBoundsException：数组索引越界异常。
int[] arr = new int[3]; int value = arr[5]; // 轰！ArrayIndexOutOfBoundsException -
ClassCastException：类型转换异常。
Object obj = "Hello"; Integer num = (Integer) obj; // 轰！ClassCastException -
NumberFormatException：数字格式异常。
String str = "abc"; int num = Integer.parseInt(str); // 轰！NumberFormatException -
IOException：输入输出异常，读写文件时可能遇到。
FileReader fr = new FileReader("不存在的文件.txt"); // 可能抛出FileNotFoundException
异常处理机制
Java提供了几种处理异常的方式，让我们一个一个来看：
1. try-catch-finally
最基础也是最常用的方式是使用try-catch-finally块：
try {
// 可能抛出异常的代码
File file = new File("example.txt");
FileReader fr = new FileReader(file);
// 其他代码...
} catch (FileNotFoundException e) {
// 处理FileNotFoundException的代码
System.out.println("文件未找到: " + e.getMessage());
} catch (IOException e) {
// 处理其他IO异常的代码
System.out.println("IO异常: " + e.getMessage());
} finally {
// 无论是否发生异常都会执行的代码
// 通常用于资源清理
System.out.println("这部分代码总是会执行");
}
从Java 7开始，可以在一个catch块中处理多种异常，使代码更简洁：
try {
// 可能抛出异常的代码
} catch (FileNotFoundException | NullPointerException e) {
// 处理这两种异常的代码
}
2. try-with-resources
Java 7引入了这个超级实用的功能！！！它自动关闭实现了AutoCloseable接口的资源，即使发生异常也能确保资源被正确关闭：
try (FileReader fr = new FileReader("example.txt");
BufferedReader br = new BufferedReader(fr)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.out.println("发生IO异常: " + e.getMessage());
}
// 不需要finally块来关闭资源，自动处理！
这种方式比传统的try-catch-finally更简洁，也更不容易出错。强烈推荐使用！
3. throws关键字
如果一个方法不想处理某个异常，可以使用throws关键字将异常"抛"给调用者：
public void readFile(String fileName) throws IOException {
FileReader fr = new FileReader(fileName);
// 读取文件的代码...
}
// 调用者必须处理这个异常
public void processFile() {
try {
readFile("example.txt");
} catch (IOException e) {
// 处理异常
}
}
4. throw关键字
有时候，你需要手动抛出异常：
public void checkAge(int age) {
if (age < 0) {
throw new IllegalArgumentException("年龄不能为负数");
}
// 正常处理逻辑...
}
自定义异常
虽然Java提供了丰富的异常类，但有时候我们需要创建自己的异常类来表达特定的业务错误。创建自定义异常非常简单：
public class InsufficientFundsException extends Exception {
private double amount;
public InsufficientFundsException(double amount) {
super("余额不足，还差: " + amount + "元");
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
// 使用自定义异常
public void withdraw(double amount) throws InsufficientFundsException {
if (balance < amount) {
throw new InsufficientFundsException(amount - balance);
}
balance -= amount;
}
自定义异常应该遵循一些最佳实践：
- 命名应以"Exception"结尾
- 通常应该继承
Exception(受检异常)或RuntimeException(非受检异常) - 应该提供构造函数，至少包括一个无参构造函数和一个带有描述性消息的构造函数
- 应该是可序列化的（通过继承
Exception自动实现）
异常处理最佳实践
掌握了基础知识，我们来看看一些实用的最佳实践（这些可是血泪经验啊）：
1. 只捕获可以处理的异常
不要盲目捕获所有异常然后什么都不做，这是一种很糟糕的编程习惯：
// 糟糕的做法
try {
// 一堆代码
} catch (Exception e) {
// 什么也不做，或者只是简单打印
e.printStackTrace();
}
// 好的做法
try {
// 一堆代码
} catch (SpecificException e) {
// 针对性处理
log.error("发生特定错误，原因：", e);
// 恢复或通知用户
}
2. 异常粒度要适当
捕获异常的粒度要合适，不要把所有代码都放在一个大的try块中：
// 糟糕的做法
try {
openFile();
readFile();
processData();
saveResults();
closeFile();
} catch (Exception e) {
// 这里无法区分是哪一步出了问题
}
// 好的做法
try {
openFile();
try {
readFile();
try {
processData();
saveResults();
} catch (DataProcessException e) {
// 处理数据处理异常
}
} catch (ReadException e) {
// 处理读取异常
}
} catch (FileOpenException e) {
// 处理文件打开异常
} finally {
closeFile(); // 确保文件关闭
}
当然，上面的嵌套太多也不好，实际中可能会用不同的方法来分隔这些操作。
3. 不要吞掉异常
捕获异常后至少要做一些有意义的处理，不要静默忽略：
// 糟糕的做法
try {
doSomething();
} catch (Exception e) {
// 什么也不做
}
// 好的做法
try {
doSomething();
} catch (Exception e) {
logger.error("执行操作失败", e);
notifyUser("很抱歉，操作失败，请稍后再试");
// 可能的恢复机制
}
4. 尽早抛出，尽晚捕获
这条原则很重要！在发现问题的地方立即抛出异常，而在能够适当处理的地方才捕获：
// 好的做法
public void validateInput(String input) {
if (input == null || input.isEmpty()) {
throw new IllegalArgumentException("输入不能为空");
}
// 其他验证...
}
public void processUserInput() {
try {
String input = getUserInput();
validateInput(input);
// 处理有效输入
} catch (IllegalArgumentException e) {
// 在这里处理无效输入
showErrorToUser(e.getMessage());
}
}
5. 利用异常层次结构
合理利用异常的继承层次，可以使代码更加清晰和可维护：
// 定义异常层次
public class ServiceException extends Exception { ... }
public class DatabaseException extends ServiceException { ... }
public class NetworkException extends ServiceException { ... }
// 使用时可以根据需要捕获特定异常或父类异常
try {
service.doSomething();
} catch (DatabaseException e) {
// 处理数据库异常
} catch (NetworkException e) {
// 处理网络异常
} catch (ServiceException e) {
// 处理其他服务异常
}
性能考虑
异常处理虽好，但用不好也会带来性能问题：
-
不要用异常控制正常流程：异常机制的开销相对较大，不应该用来控制正常的程序流程。
// 糟糕的做法 try { int index = list.indexOf(item); list.get(index); // 可能抛出IndexOutOfBoundsException } catch (IndexOutOfBoundsException e) { // 处理找不到元素的情况 } // 好的做法 int index = list.indexOf(item); if (index != -1) { list.get(index); } else { // 处理找不到元素的情况 } -
避免过度记录异常：在生产环境中，过度记录异常（尤其是在高频调用的代码路径上）会产生大量日志，影响性能。
-
重用异常对象：在特定场景下，如果一个异常会被频繁抛出，可以考虑重用异常对象而不是每次创建新的。
实战：一个完整的异常处理示例
让我们来看一个更完整的示例，展示如何在真实场景中应用异常处理：
public class BankAccount {
private String accountNumber;
private double balance;
private static final Logger logger = LoggerFactory.getLogger(BankAccount.class);
public BankAccount(String accountNumber, double initialBalance) {
if (accountNumber == null || accountNumber.trim().isEmpty()) {
throw new IllegalArgumentException("账号不能为空");
}
if (initialBalance < 0) {
throw new IllegalArgumentException("初始余额不能为负数");
}
this.accountNumber = accountNumber;
this.balance = initialBalance;
}
public void deposit(double amount) throws InvalidAmountException {
try {
if (amount <= 0) {
throw new InvalidAmountException("存款金额必须为正数");
}
balance += amount;
logger.info("账户{}存款成功，金额：{}", accountNumber, amount);
} catch (InvalidAmountException e) {
logger.error("账户{}存款失败：{}", accountNumber, e.getMessage(), e);
throw e; // 重新抛出以便调用者知道操作失败
} catch (Exception e) {
logger.error("账户{}存款时发生未知错误", accountNumber, e);
throw new BankServiceException("处理存款时发生错误", e);
}
}
public void withdraw(double amount) throws InsufficientFundsException, InvalidAmountException {
if (amount <= 0) {
throw new InvalidAmountException("取款金额必须为正数");
}
if (amount > balance) {
double shortfall = amount - balance;
throw new InsufficientFundsException(shortfall);
}
try {
balance -= amount;
logger.info("账户{}取款成功，金额：{}", accountNumber, amount);
} catch (Exception e) {
logger.error("账户{}取款时发生未知错误", accountNumber, e);
// 恢复状态（在真实系统中可能需要更复杂的事务处理）
balance += amount;
throw new BankServiceException("处理取款时发生错误", e);
}
}
public double getBalance() {
return balance;
}
// 自定义异常类
public static class InvalidAmountException extends Exception {
public InvalidAmountException(String message) {
super(message);
}
}
public static class InsufficientFundsException extends Exception {
private final double shortfall;
public InsufficientFundsException(double shortfall) {
super("余额不足，还差" + shortfall + "元");
this.shortfall = shortfall;
}
public double getShortfall() {
return shortfall;
}
}
public static class BankServiceException extends RuntimeException {
public BankServiceException(String message, Throwable cause) {
super(message, cause);
}
}
}
使用这个银行账户类的客户端代码：
public class BankClient {
public static void main(String[] args) {
try {
BankAccount account = new BankAccount("1234-5678", 1000.0);
try {
account.deposit(500.0);
System.out.println("当前余额: " + account.getBalance());
} catch (BankAccount.InvalidAmountException e) {
System.out.println("存款失败: " + e.getMessage());
}
try {
account.withdraw(2000.0);
System.out.println("取款成功，当前余额: " + account.getBalance());
} catch (BankAccount.InsufficientFundsException e) {
System.out.println("取款失败: " + e.getMessage());
System.out.println("是否要申请贷款？缺口金额: " + e.getShortfall());
} catch (BankAccount.InvalidAmountException e) {
System.out.println("取款金额无效: " + e.getMessage());
}
} catch (IllegalArgumentException e) {
System.out.println("创建账户失败: " + e.getMessage());
} catch (BankAccount.BankServiceException e) {
System.out.println("银行服务异常: " + e.getMessage());
System.out.println("请联系客服解决问题");
}
}
}
总结
掌握Java异常处理是编写健壮、可维护代码的关键技能。让我们回顾一下要点：
- 理解异常的层次结构和类型（受检vs非受检）
- 熟练使用try-catch-finally和try-with-resources
- 适当使用throws和throw关键字
- 创建有意义的自定义异常
- 遵循异常处理的最佳实践：
- 只捕获能处理的异常
- 不吞掉异常
- 适当的异常粒度
- 尽早抛出，尽晚捕获
- 合理使用异常层次结构
- 注意异常处理对性能的影响
异常处理不仅是应对错误的机制，更是设计良好代码的一部分。当你掌握了这些技巧，你的代码会更加健壮，也更容易维护和扩展。
希望这篇文章对你有所帮助！无论你是Java新手还是有经验的开发者，都值得花时间深入理解和实践这些异常处理技巧。编码快乐！
扫一扫
963
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
