41招高效攻略,构建异常处理机制，让程序稳定运行告别崩溃
在编程中，异常处理是一种确保程序在面对错误情况时能够优雅地处理问题，而不是直接崩溃的方法。以下是一个使用Python语言实现的简单异常处理机制的例子：
```python
def divide(a, b):
try:
result = a / b
except ZeroDivisionError:
print("错误：除数不能为0")
result = None
except TypeError:
print("错误：输入必须是数字")
result = None
except Exception as e:
print(f"未知错误：{e}")
result = None
else:
print("除法操作成功")
finally:
print("结束除法操作")
return result
# 测试代码
print(divide(10, 2)) # 正常情况
print(divide(10, 0)) # 除以0的情况
print(divide(10, 'a')) # 错误类型的情况
```
这段代码中，`divide` 函数尝试执行除法操作，并包含了以下几种异常处理：
- `ZeroDivisionError`：当除数为0时抛出。
- `TypeError`：当输入的不是数字时抛出。
- `Exception`：捕获所有其他类型的异常。
使用 `try...except...else...finally` 结构来处理可能发生的异常：
- `try` 块尝试执行可能抛出异常的代码。
- `except` 块捕获
相关内容：
我是老陈，这节课一起来学习异常处理机制 ，它就像 “程序的安全气囊”，当代码运行出现意外时，异常机制会瞬间 “激活”，让程序从错误中优雅恢复而非崩溃。
异常处理的核心思想：将 “错误处理逻辑” 与 “业务逻辑” 分离，用try-catch-finally结构捕获异常，用异常类的层次结构区分错误类型。
41.1 异常处理的核心特性：错误分类与捕获机制
异常处理就像 “智能家居安全系统”—— 不同的异常场景如同家中突发的安全事件（如漏水、断电），而try-catch机制则像家庭智能控制中心，通过识别异常类型启动对应的应急预案。
package com.exception.demo;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @author 今日：老陈说编程
* 异常分类与捕获机制基础演示
* 展示Java中受检异常、非受检异常的处理方式以及异常传播机制
*/
public class ExceptionBasicFeatures {
public static void main(String args) {
// 1. 受检异常（Checked Exception）演示：
// 必须显式处理（使用try-catch捕获或在方法签名声明throws）
try {
// 创建文件输入流，若文件不存在则抛出FileNotFoundException（IOException子类）
FileInputStream fis = new FileInputStream("data.txt");
int data = fis.read(); // 读取文件内容，可能抛出IOException
fis.close(); // 关闭资源，可能抛出IOException
} catch (IOException e) {
// 捕获并处理文件操作相关异常
System.out.println("文件读取错误：" + e.getMessage());
e.printStackTrace(); // 打印详细异常堆栈，便于调试
}
// 2. 非受检异常（Unchecked Exception/RuntimeException）演示：
// 无需强制处理，由JVM在运行时自动抛出
try {
int nums = null; // 定义空引用
System.out.println(nums.length); // 访问空对象属性，触发NullPointerException
} catch (NullPointerException e) {
// 可选的异常捕获处理
System.out.println("空指针错误：" + e.getMessage());
}
// 3. 异常传播机制示例：
// 异常会沿调用栈向上传播，直到被捕获或导致程序终止
try {
pide(10, 0); // 调用方法，可能触发ArithmeticException
} catch (ArithmeticException e) {
// 处理除数为零的异常
System.out.println("除法错误已处理：" + e.getMessage());
}
}
// 抛出异常的方法（非受检异常无需在方法签名声明）
// @param a 被除数
// @param b 除数
// @return 除法运算结果
// @throws ArithmeticException 当除数b为0时抛出
static int pide(int a, int b) {
return a / b; // 当b=0时触发ArithmeticException（继承自RuntimeException）
}
} 41.2 核心语法：try-catch-finally 的三种形态
旁白：异常处理语法就像 “不同规格的安全网”—— 根据业务场景选择合适的捕获方式，从基础的单异常捕获到复杂的多资源管理，每种形态都有其适用场景。
package com.exception.demo;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* @author 今日：老陈说编程
* 异常处理语法三种形态综合演示
* 包含基础try-catch、多重catch和try-with-resources语法的使用示例
*/
public class ExceptionSyntax {
public static void main(String args) {
// 1. 基础try-catch结构演示
// 捕获特定类型的异常并进行处理
try {
int result = 10 / 0; // 触发ArithmeticException异常
} catch (ArithmeticException e) {
// 捕获算术异常并输出错误信息
System.out.println("基础捕获：除数不能为0");
}
// 2. 多重catch结构演示
// 注意异常捕获顺序：子类异常必须放在父类异常之前
try {
Object obj = "字符串";
Integer num = (Integer) obj; // 触发ClassCastException异常
} catch (ClassCastException e) {
// 捕获类型转换异常
System.out.println("类型转换错误");
} catch (Exception e) {
// 捕获通用异常，处理其他未被特定catch块处理的异常
System.out.println("通用异常处理");
}
// 3. try-with-resources自动关闭资源演示（Java 7+特性）
// 传统方式：需要在finally块中手动关闭资源
BufferedReader reader1 = null;
try {
reader1 = new BufferedReader(new FileReader("data.txt"));
String line = reader1.readLine();
} catch (IOException e) {
System.out.println("传统方式IO错误");
} finally {
// 确保资源被关闭，即使发生异常
if (reader1 != null) {
try {
reader1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// try-with-resources方式：自动关闭实现了AutoCloseable接口的资源
try (BufferedReader reader2 = new BufferedReader(new FileReader("data.txt"))) {
String line = reader2.readLine();
System.out.println("try-with-resources读取：" + line);
} catch (IOException e) {
System.out.println("新方式IO错误");
}
// 4. finally块特性演示
// finally块中的代码无论是否发生异常都会执行
try {
System.out.println("try块执行");
return; // 在return前会先执行finally块中的代码
} catch (Exception e) {
System.out.println("catch块执行");
} finally {
System.out.println("finally块必定执行");
}
}
} 41.3 自定义异常与业务场景：错误处理的领域化实践
自定义异常就像 “企业专属的急救流程”—— 根据业务需求定义特定异常（如UserNotFoundException），让错误信息更贴合业务场景，便于快速定位问题。
package com.exception.demo;
/**
* @author 今日：老陈说编程
* 用户类，封装用户基本信息
* 包含姓名和年龄属性，提供对应的访问器方法
*/
class User {
private String name; // 用户姓名
private int age; // 用户年龄
/**
* 构造函数初始化用户对象
*
* @param name 用户姓名
* @param age 用户年龄
*/
public User(String name, int age) {
this.name = name;
this.age = age;
}
// 姓名访问器
public String getName() {
return name;
}
// 年龄访问器
public int getAge() {
return age;
}
}
/**
* 用户不存在异常（非受检异常）
* 继承自RuntimeException，用于表示查询用户不存在的场景
*/
class UserNotFoundException extends RuntimeException {
/**
* 构造函数接收异常消息
*
* @param message 异常描述信息
*/
public UserNotFoundException(String message) {
super(message);
}
}
/**
* 用户参数无效异常（受检异常）
* 继承自Exception，用于表示用户输入参数不符合业务规则的场景
*/
class InvalidUserException extends Exception {
/**
* 构造函数接收异常消息
*
* @param message 异常描述信息
*/
public InvalidUserException(String message) {
super(message);
}
}
/**
* 用户服务类，处理用户相关业务逻辑
* 包含用户查询和保存等核心业务方法
*/
class UserService {
/**
* 根据用户ID查询用户信息
*
* @param id 用户ID
* @return 匹配的用户对象
* @throws UserNotFoundException 当ID无效或用户不存在时抛出
*/
public User getUserById(int id) {
// 校验ID有效性
if (id <= 0) {
throw new UserNotFoundException("用户ID必须大于0");
}
// 模拟数据库查询逻辑（实际应用中会调用DAO层）
if (id == 100) {
return new User("张三", 25);
}
// 未找到匹配用户
throw new UserNotFoundException("用户ID " + id + " 不存在");
}
/**
* 保存用户信息
*
* @param user 用户对象
* @throws InvalidUserException 当用户对象或参数不合法时抛出
*/
public void saveUser(User user) throws InvalidUserException {
// 校验用户对象有效性
if (user == null) {
throw new InvalidUserException("用户对象不能为空");
}
// 校验用户姓名
if (user.getName() == null || user.getName().isEmpty()) {
throw new InvalidUserException("用户名不能为空");
}
// 模拟保存逻辑（实际应用中会持久化到数据库）
System.out.println("保存用户：" + user.getName());
}
}
/**
* 主类，程序入口点
*/
public class CustomException {
public static void main(String args) {
UserService service = new UserService();
try {
// 测试用户查询功能 - 正常情况
User user = service.getUserById(100);
System.out.println("查询成功：" + user.getName());
// 测试保存用户 - 故意传递无效参数触发异常
service.saveUser(new User(null, 30));
} catch (UserNotFoundException e) {
// 处理非受检异常（运行时异常）
System.out.println("业务异常：" + e.getMessage());
} catch (InvalidUserException e) {
// 处理受检异常（编译时异常）
System.out.println("参数异常：" + e.getMessage());
}
}
}总结异常处理机制的适用场景
输入验证：在方法入口处验证参数合法性（如if (param == null) throw new IllegalArgumentException()）。
资源管理：使用try-with-resources自动关闭文件流、数据库连接等资源。
业务异常：根据业务场景定义专属异常（如OrderNotFoundException），提升错误定位效率。
第三方调用：捕获第三方 API 可能抛出的异常，转换为自定义异常后重新抛出。
跨层错误传递：在多层架构中，将底层技术异常，如SQLException。封装为业务异常向上传递。
下期将学习多线程编程，记得点赞关注，评论区留下你对异常处理的疑问，我们一起解决！