Java 异常处理机制详解

异常处理是Java编程语言的一个重要特性，它提供了一种结构化和受控的方式来处理程序运行时出现的错误或异常情况。良好的异常处理机制能够提高程序的健壮性、可维护性和用户体验。

本文内容概览

1. 异常基础概念
2. Java异常体系结构
- 2.1 异常层次结构
- 2.2 异常分类详解
3. 异常处理机制
4. 异常抛出与传播
5. 自定义异常
- 5.1 创建自定义异常类
- 5.2 异常链（Exception Chaining）
6. 异常处理最佳实践
7. 常见异常处理模式
8. 面试题精选
9. 总结

核心概念

异常处理 = 异常捕获 + 异常处理 + 资源管理 + 错误恢复

核心价值

异常处理 = 异常捕获 + 异常处理 + 资源管理 + 错误恢复

🛡️ 结构化处理：提供统一的错误处理机制，增强代码健壮性
🔍 问题定位：提供详细的堆栈跟踪，快速定位问题根源
🔄 流程控制：允许程序从错误中恢复并继续执行
🧹 资源管理：确保资源正确释放，防止资源泄露
📝 代码分离：分离正常逻辑与错误处理逻辑，提高可读性

1. 异常基础概念

1.1 什么是异常？

异常是程序执行期间发生的事件，它会中断程序指令的正常流程。当方法中发生错误时，方法会创建一个异常对象并交给JVM处理。

异常的本质
异常处理流程
异常演示

异常不是错误：而是一种机制，用于处理程序执行过程中的异常情况
中断正常流程：当异常发生时，正常的程序执行流程会被中断
异常对象：每个异常都是一个对象，包含错误信息和堆栈跟踪
异常传播：异常会沿着调用栈向上传播，直到被处理

异常处理的意义

异常处理让程序能够优雅地处理错误并继续执行，而不是简单地崩溃。这对于生产环境的应用程序尤为重要。

异常发生：执行代码时遇到异常情况
创建异常对象：创建描述异常的对象（如 NullPointerException）
抛出异常：从当前执行点中断代码执行，并"抛出"异常对象
寻找处理器：JVM查找适当的异常处理器（向上查找调用堆栈）
执行处理器：执行找到的异常处理代码（catch块）
执行清理：执行清理代码（finally块）
恢复执行：从异常处理器之后的点继续执行

未处理的异常

如果异常在调用堆栈中未被捕获，则程序终止，JVM将异常信息打印到控制台。

java

1public void demonstrateException() {
2    try {
3        System.out.println("执行正常代码...");
4        String str = null;
5        // 下面这行会抛出NullPointerException
6        System.out.println(str.length());
7        System.out.println("这行代码不会执行");
8    } catch (NullPointerException e) {
9        System.err.println("捕获异常: " + e.getMessage());
10        e.printStackTrace();
11    } finally {
12        System.out.println("无论是否有异常都会执行");
13    }
14    System.out.println("继续执行后续代码");
15}

执行结果：

1执行正常代码...
2捕获异常: null
3java.lang.NullPointerException
4    at Example.demonstrateException(Example.java:6)
5    at Example.main(Example.java:12)
6无论是否有异常都会执行
7继续执行后续代码

1.2 异常处理的优点

优点	说明	示例
代码分离	把正常代码和错误处理代码分离，增强可读性	try-catch块分离业务逻辑和异常处理
错误分组	把各种不同的错误类型分组，并用不同的方式进行处理	按异常类型分别处理IOException和SQLException
提高健壮性	提高程序的健壮性和可靠性	网络异常时自动重试，文件不存在时创建默认配置
调试友好	提供良好的调试信息，帮助定位问题	详细的异常堆栈信息和错误描述
用户体验	避免程序崩溃，提供友好的错误提示	显示用户友好的错误消息而不是技术细节

1.3 异常处理的基本流程

异常处理基本流程

java

1public class ExceptionFlowDemo {
2    public static void main(String[] args) {
3        try {
4            // 1. 执行可能抛出异常的代码
5            String result = riskyOperation();
6            System.out.println("操作成功: " + result);
7            
8        } catch (Exception e) {
9            // 2. 捕获并处理异常
10            System.err.println("操作失败: " + e.getMessage());
11            
12        } finally {
13            // 3. 清理资源（无论是否发生异常都会执行）
14            cleanup();
15        }
16    }
17    
18    private static String riskyOperation() throws Exception {
19        // 模拟可能抛出异常的操作
20        if (Math.random() < 0.5) {
21            throw new Exception("随机错误");
22        }
23        return "成功结果";
24    }
25    
26    private static void cleanup() {
27        System.out.println("清理资源完成");
28    }
29}

2. Java异常体系结构

Java的异常体系是一个由各种异常类组成的层次结构，所有异常类都是java.lang.Throwable类的子类。

2.1 异常层次结构

层次结构
对比说明
常见异常示例

1Throwable (可抛出对象)
2├── Error (系统错误，通常不可恢复)
3│   ├── OutOfMemoryError (内存不足)
4│   ├── StackOverflowError (栈溢出)
5│   ├── VirtualMachineError (虚拟机错误)
6│   └── LinkageError (链接错误)
7└── Exception (程序异常，通常可恢复)
8    ├── RuntimeException (运行时异常，非检查型)
9    │   ├── NullPointerException (空指针异常)
10    │   ├── ArrayIndexOutOfBoundsException (数组越界)
11    │   ├── ClassCastException (类型转换异常)
12    │   ├── IllegalArgumentException (非法参数异常)
13    │   ├── NumberFormatException (数字格式异常)
14    │   └── IndexOutOfBoundsException (索引越界异常)
15    └── 其他Exception (检查型异常)
16        ├── IOException (输入输出异常)
17        ├── SQLException (数据库异常)
18        ├── ClassNotFoundException (类未找到异常)
19        ├── InterruptedException (中断异常)
20        └── ParseException (解析异常)

特征	Error	Exception	RuntimeException
类型	系统级错误	程序异常	程序运行时异常
可恢复性	通常不可恢复	通常可恢复	可恢复
检查性质	非检查型	检查型(RuntimeException除外)	非检查型
编译检查	不强制处理	强制处理(try-catch或throws)	不强制处理
发生阶段	运行时	编译期或运行时	运行时
处理策略	一般不处理	必须处理	预防为主
示例	OutOfMemoryError	IOException	NullPointerException

Error示例

OutOfMemoryError: 内存溢出，无法分配新对象
StackOverflowError: 栈溢出，常见于无限递归
NoClassDefFoundError: 找不到类定义

检查型异常示例

IOException: 输入输出操作失败
SQLException: 数据库访问错误
ClassNotFoundException: 类加载失败

运行时异常示例

NullPointerException: 访问null对象的成员
ArrayIndexOutOfBoundsException: 数组访问越界
ClassCastException: 类型转换失败

2.2 异常分类详解

2.2.1 检查型异常（Checked Exception）

检查型异常是编译器强制要求处理的异常，它们表示程序可以预见的、可能发生的错误情况。

特点：

编译器强制要求：开发者必须在代码中显式处理这些异常
可恢复性：通常表示可恢复的错误情况
调用者责任：调用者应该知道并处理这些异常
方法签名：必须在方法签名中声明或处理

典型代表：

检查型异常示例

java

1public class CheckedExceptionDemo {
2    public static void main(String[] args) {
3        try {
4            // 读取文件可能抛出IOException
5            readFile("example.txt");
6            
7            // 连接数据库可能抛出SQLException
8            connectDatabase();
9            
10        } catch (IOException e) {
11            System.err.println("文件读取错误: " + e.getMessage());
12        } catch (SQLException e) {
13            System.err.println("数据库连接错误: " + e.getMessage());
14        }
15    }
16    
17    // 方法必须声明可能抛出的检查型异常
18    public static void readFile(String filename) throws IOException {
19        // 文件操作代码
20        if (!new File(filename).exists()) {
21            throw new IOException("文件不存在: " + filename);
22        }
23    }
24    
25    public static void connectDatabase() throws SQLException {
26        // 数据库连接代码
27        throw new SQLException("数据库连接失败");
28    }
29}

2.2.2 运行时异常（Runtime Exception）

运行时异常是RuntimeException及其子类，编译器不强制要求处理，通常表示编程错误。

特点：

编译器不强制要求：开发者可以选择处理或不处理
不可预见性：通常表示编程错误或不可恢复的系统错误
程序逻辑问题：如空指针、数组越界、类型转换错误等
开发阶段问题：应该在开发阶段发现并修复

典型代表：

运行时异常示例

java

1public class RuntimeExceptionDemo {
2    public static void main(String[] args) {
3        try {
4            // 空指针异常
5        String str = null;
6            System.out.println(str.length()); // NullPointerException
7        
8        } catch (NullPointerException e) {
9            System.err.println("空指针异常: " + e.getMessage());
10        }
11        
12        try {
13            // 数组越界异常
14            int[] array = {1, 2, 3};
15            System.out.println(array[5]); // ArrayIndexOutOfBoundsException
16            
17        } catch (ArrayIndexOutOfBoundsException e) {
18            System.err.println("数组越界异常: " + e.getMessage());
19        }
20        
21        try {
22            // 类型转换异常
23            Object obj = "Hello";
24            Integer num = (Integer) obj; // ClassCastException
25            
26        } catch (ClassCastException e) {
27            System.err.println("类型转换异常: " + e.getMessage());
28        }
29    }
30}

2.2.3 错误（Error）

错误表示严重的问题，程序通常无法恢复，通常不需要捕获。

特点：

严重性问题：表示JVM或系统级别的严重问题
无法恢复：程序通常无法从这些错误中恢复
不需要捕获：通常不需要也不应该捕获这些错误
系统问题：如内存不足、栈溢出等

典型代表：

错误示例

java

1public class ErrorDemo {
2    public static void main(String[] args) {
3        try {
4            // 栈溢出错误
5            recursiveMethod(0);
6            
7        } catch (StackOverflowError e) {
8            // 通常不应该捕获Error
9            System.err.println("栈溢出错误: " + e.getMessage());
10        }
11        
12        try {
13            // 内存不足错误
14            allocateLargeMemory();
15            
16        } catch (OutOfMemoryError e) {
17            System.err.println("内存不足错误: " + e.getMessage());
18        }
19    }
20    
21    // 递归方法可能导致栈溢出
22    private static void recursiveMethod(int count) {
23        recursiveMethod(count + 1);
24    }
25    
26    // 分配大量内存可能导致内存不足
27    private static void allocateLargeMemory() {
28        List<byte[]> list = new ArrayList<>();
29        while (true) {
30            list.add(new byte[1024 * 1024]); // 1MB
31        }
32    }
33}

异常分类的重要性

正确理解异常分类有助于选择合适的处理策略：

检查型异常：通常表示可恢复的错误，应该被处理
运行时异常：通常表示编程错误，应该在开发阶段避免
错误：通常表示系统问题，通常不需要捕获

3. 异常处理机制

3.1 try-catch-finally 语句

try-catch-finally是Java异常处理的核心语句，它提供了完整的异常处理机制。

基本语法
执行流程
使用规则

try-catch-finally基本语法

java

1try {
2    // 可能抛出异常的代码块
3    riskyOperation();
4    
5} catch (SpecificException e) {
6    // 处理特定类型的异常
7    handleSpecificException(e);
8    
9} catch (Exception e) {
10    // 处理其他类型的异常
11    handleGeneralException(e);
12    
13} finally {
14    // 清理资源，无论是否发生异常都会执行
15    cleanup();
16}

重要规则

catch块必须从最具体的异常类型到最一般的异常类型排序
finally块即使在try或catch块中有return语句，也会执行
不要在finally块中使用return语句，可能覆盖try/catch块的返回值
在finally块中抛出的异常会覆盖try/catch块中的异常

java

1// 错误的catch块顺序
2try {
3    // 代码
4} catch (Exception e) {         // 先捕获一般异常
5    // 处理
6} catch (IOException e) {       // 永远不会执行！
7    // 处理
8}
9
10// 正确的catch块顺序
11try {
12    // 代码
13} catch (IOException e) {       // 先捕获特定异常
14    // 处理
15} catch (Exception e) {         // 再捕获一般异常
16    // 处理
17}

3.1.2 详细示例

完整的异常处理示例

java

1public class ExceptionHandlingDemo {
2    public static void main(String[] args) {
3        FileInputStream fis = null;
4        
5        try {
6            // 尝试打开文件
7            fis = new FileInputStream("example.txt");
8            
9            // 读取文件内容
10            int data;
11            while ((data = fis.read()) != -1) {
12                System.out.print((char) data);
13            }
14            
15        } catch (FileNotFoundException e) {
16            // 处理文件未找到异常
17            System.err.println("文件未找到: " + e.getMessage());
18            System.err.println("请检查文件路径是否正确");
19            
20        } catch (IOException e) {
21            // 处理IO异常
22            System.err.println("文件读取错误: " + e.getMessage());
23            
24        } catch (Exception e) {
25            // 处理其他未知异常
26            System.err.println("发生未知错误: " + e.getMessage());
27            e.printStackTrace(); // 打印详细堆栈信息
28            
29        } finally {
30            // 清理资源
31            if (fis != null) {
32                try {
33                    fis.close();
34                    System.out.println("文件已关闭");
35                } catch (IOException e) {
36                    System.err.println("关闭文件时发生错误: " + e.getMessage());
37                }
38            }
39        }
40    }
41}

3.2 多重异常捕获

Java 7引入了多重异常捕获语法，可以简化代码并避免重复的异常处理逻辑。

3.2.1 传统方式

传统异常捕获方式

java

1public class TraditionalExceptionHandling {
2    public static void main(String[] args) {
3        try {
4            // 可能抛出多种异常的代码
5            processData();
6            
7        } catch (IOException e) {
8            // 处理IO异常
9            System.err.println("IO错误: " + e.getMessage());
10            
11        } catch (SQLException e) {
12            // 处理SQL异常
13            System.err.println("数据库错误: " + e.getMessage());
14            
15        } catch (ParseException e) {
16            // 处理解析异常
17            System.err.println("解析错误: " + e.getMessage());
18        }
19    }
20    
21    private static void processData() throws IOException, SQLException, ParseException {
22        // 模拟可能抛出多种异常的操作
23        if (Math.random() < 0.3) {
24            throw new IOException("文件读取失败");
25        } else if (Math.random() < 0.6) {
26            throw new SQLException("数据库查询失败");
27        } else {
28            throw new ParseException("数据解析失败", 0);
29        }
30    }
31}

3.2.2 多重异常捕获（Java 7+）

多重异常捕获

java

1public class MultiCatchDemo {
2    public static void main(String[] args) {
3        try {
4            // 可能抛出多种异常的代码
5            processData();
6            
7        } catch (IOException | SQLException | ParseException e) {
8            // 统一处理多种异常
9            System.err.println("处理数据时发生错误: " + e.getMessage());
10            
11            // 可以根据异常类型进行不同的处理
12            if (e instanceof IOException) {
13                System.err.println("这是一个IO错误");
14            } else if (e instanceof SQLException) {
15                System.err.println("这是一个数据库错误");
16            } else if (e instanceof ParseException) {
17                System.err.println("这是一个解析错误");
18            }
19        }
20    }
21    
22    private static void processData() throws IOException, SQLException, ParseException {
23        // 模拟可能抛出多种异常的操作
24        if (Math.random() < 0.3) {
25            throw new IOException("文件读取失败");
26        } else if (Math.random() < 0.6) {
27            throw new SQLException("数据库查询失败");
28        } else {
29            throw new ParseException("数据解析失败", 0);
30        }
31    }
32}

多重异常捕获的优势

代码简洁：避免重复的catch块
维护性好：统一的异常处理逻辑
类型安全：编译时检查异常类型
性能优化：避免重复的异常处理代码

3.3 try-with-resources 语句

Java 7引入了try-with-resources语句，它自动管理实现了AutoCloseable接口的资源，确保资源被正确关闭。

对比说明
语法演进

特性	传统 try-finally	try-with-resources
代码复杂度	高（需要嵌套try-catch）	低（语法简洁）
资源关闭	手动关闭	自动关闭
异常处理	关闭资源的异常可能掩盖原始异常	保留原始异常，关闭异常作为被抑制异常
适用资源	任何需要关闭的资源	实现了AutoCloseable接口的资源
Java版本	所有版本	Java 7及以上

Java 9增强的try-with-resources

java

1// Java 7/8: 资源必须在try语句中声明
2try (FileInputStream fis = new FileInputStream("input.txt")) {
3    // 使用资源
4}
5
6// Java 9+: 支持使用final或effectively final的外部变量
7FileInputStream fis = new FileInputStream("input.txt");
8try (fis) { // 使用已存在的资源变量
9    // 使用资源
10}

注意

要使用Java 9增强的try-with-resources语法，变量必须是final或effectively final（一旦赋值后不再更改）。

3.3.1 传统资源管理

传统资源管理方式

java

1public class TraditionalResourceManagement {
2    public static void main(String[] args) {
3        FileInputStream fis = null;
4        FileOutputStream fos = null;
5        
6        try {
7            fis = new FileInputStream("input.txt");
8            fos = new FileOutputStream("output.txt");
9            
10            // 复制文件内容
11            int data;
12            while ((data = fis.read()) != -1) {
13                fos.write(data);
14            }
15            
16        } catch (IOException e) {
17            System.err.println("文件操作错误: " + e.getMessage());
18            
19        } finally {
20            // 手动关闭资源
21            if (fis != null) {
22                try {
23                    fis.close();
24                } catch (IOException e) {
25                    System.err.println("关闭输入流时发生错误: " + e.getMessage());
26                }
27            }
28            
29            if (fos != null) {
30                try {
31                    fos.close();
32                } catch (IOException e) {
33                    System.err.println("关闭输出流时发生错误: " + e.getMessage());
34                }
35            }
36        }
37    }
38}

3.3.2 try-with-resources 方式

try-with-resources方式

java

1public class TryWithResourcesDemo {
2    public static void main(String[] args) {
3        // 自动管理资源，无需手动关闭
4        try (FileInputStream fis = new FileInputStream("input.txt");
5             FileOutputStream fos = new FileOutputStream("output.txt")) {
6            
7            // 复制文件内容
8            int data;
9            while ((data = fis.read()) != -1) {
10                fos.write(data);
11            }
12            
13        } catch (IOException e) {
14            System.err.println("文件操作错误: " + e.getMessage());
15        }
16        // 资源自动关闭，无需finally块
17    }
18}

3.3.3 自定义AutoCloseable资源

自定义AutoCloseable资源

java

1public class CustomResource implements AutoCloseable {
2    private String name;
3    
4    public CustomResource(String name) {
5        this.name = name;
6        System.out.println("创建资源: " + name);
7    }
8    
9    public void use() {
10        System.out.println("使用资源: " + name);
11    }
12    
13    @Override
14    public void close() {
15        System.out.println("关闭资源: " + name);
16    }
17}
18
19public class CustomResourceDemo {
20    public static void main(String[] args) {
21        try (CustomResource resource1 = new CustomResource("Resource1");
22             CustomResource resource2 = new CustomResource("Resource2")) {
23            
24            resource1.use();
25            resource2.use();
26            
27        } catch (Exception e) {
28            System.err.println("使用资源时发生错误: " + e.getMessage());
29        }
30        // 输出：
31        // 创建资源: Resource1
32        // 创建资源: Resource2
33        // 使用资源: Resource1
34        // 使用资源: Resource2
35        // 关闭资源: Resource2
36        // 关闭资源: Resource1
37    }
38}

try-with-resources的优势

自动资源管理：无需手动关闭资源
异常安全：即使发生异常，资源也会被正确关闭
代码简洁：减少样板代码
避免资源泄漏：确保资源被正确释放

4. 异常抛出与传播

4.1 throw 语句

throw语句用于显式抛出异常，它允许程序员在特定条件下主动抛出异常。

4.1.1 基本语法

throw语句基本语法

java

1throw new ExceptionType("异常描述信息");

4.1.2 详细示例

throw语句示例

java

1public class ThrowDemo {
2    public static void main(String[] args) {
3        try {
4            // 调用可能抛出异常的方法
5            validateAge(-5);
6            validateAge(150);
7            
8        } catch (IllegalArgumentException e) {
9            System.err.println("年龄验证失败: " + e.getMessage());
10        }
11        
12        try {
13            // 调用可能抛出异常的方法
14            divide(10, 0);
15            
16        } catch (ArithmeticException e) {
17            System.err.println("除法运算失败: " + e.getMessage());
18        }
19    }
20    
21    // 验证年龄，如果无效则抛出异常
22    public static void validateAge(int age) {
23        if (age < 0) {
24            throw new IllegalArgumentException("年龄不能为负数: " + age);
25        }
26        if (age > 120) {
27            throw new IllegalArgumentException("年龄超出合理范围: " + age);
28        }
29        System.out.println("年龄验证通过: " + age);
30    }
31    
32    // 除法运算，除数为0时抛出异常
33    public static double divide(double dividend, double divisor) {
34        if (divisor == 0) {
35            throw new ArithmeticException("除数不能为0");
36        }
37        return dividend / divisor;
38    }
39}

4.2 throws 关键字

throws关键字用于在方法签名中声明可能抛出的异常，它告诉调用者需要处理这些异常。

4.2.1 基本语法

throws关键字基本语法

java

1public returnType methodName(parameters) throws ExceptionType1, ExceptionType2 {
2    // 方法体
3}

4.2.2 详细示例

throws关键字示例

java

1public class ThrowsDemo {
2    public static void main(String[] args) {
3        try {
4            // 调用声明了异常的方法
5            readFile("example.txt");
6            connectDatabase("localhost", 3306);
7            
8        } catch (IOException e) {
9            System.err.println("文件操作错误: " + e.getMessage());
10        } catch (SQLException e) {
11            System.err.println("数据库操作错误: " + e.getMessage());
12        }
13    }
14    
15    // 声明可能抛出IOException
16    public static void readFile(String filename) throws IOException {
17        if (!new File(filename).exists()) {
18            throw new IOException("文件不存在: " + filename);
19        }
20        System.out.println("文件读取成功: " + filename);
21    }
22    
23    // 声明可能抛出SQLException
24    public static void connectDatabase(String host, int port) throws SQLException {
25        if (port < 1 || port > 65535) {
26            throw new SQLException("无效的端口号: " + port);
27        }
28        System.out.println("数据库连接成功: " + host + ":" + port);
29    }
30    
31    // 声明可能抛出多种异常
32    public static void processData(String data) throws IOException, SQLException, ParseException {
33        if (data == null || data.trim().isEmpty()) {
34            throw new IllegalArgumentException("数据不能为空");
35        }
36        
37        // 模拟可能抛出异常的操作
38        if (data.contains("file")) {
39            throw new IOException("文件处理错误");
40        }
41        if (data.contains("db")) {
42            throw new SQLException("数据库处理错误");
43        }
44        if (data.contains("parse")) {
45            throw new ParseException("数据解析错误", 0);
46        }
47        
48        System.out.println("数据处理成功: " + data);
49    }
50}

4.3 异常传播机制

异常会沿着调用栈向上传播，直到被捕获或到达main方法。

4.3.1 异常传播示例

异常传播机制

java

1public class ExceptionPropagationDemo {
2    public static void main(String[] args) {
3        try {
4            // 调用方法链
5            methodA();
6            
7        } catch (Exception e) {
8            System.err.println("在main方法中捕获异常: " + e.getMessage());
9            e.printStackTrace(); // 打印完整的调用栈
10        }
11    }
12    
13    public static void methodA() throws Exception {
14        System.out.println("进入methodA");
15        try {
16            methodB();
17        } catch (Exception e) {
18            System.err.println("在methodA中捕获异常: " + e.getMessage());
19            // 可以选择重新抛出异常
20            throw e;
21        }
22        System.out.println("离开methodA");
23    }
24    
25    public static void methodB() throws Exception {
26        System.out.println("进入methodB");
27        try {
28            methodC();
29        } catch (Exception e) {
30            System.err.println("在methodB中捕获异常: " + e.getMessage());
31            throw e; // 重新抛出异常
32        }
33        System.out.println("离开methodB");
34    }
35    
36    public static void methodC() throws Exception {
37        System.out.println("进入methodC");
38        // 主动抛出异常
39        throw new Exception("在methodC中发生的异常");
40        // 下面的代码不会执行
41        // System.out.println("离开methodC");
42    }
43}

4.3.2 异常传播的特点

特点	说明	示例
向上传播	异常会沿着调用栈向上传播	methodC → methodB → methodA → main
可被拦截	任何方法都可以捕获并处理异常	在methodA中捕获异常
可重新抛出	捕获异常后可以重新抛出	`catch (Exception e) { throw e; }`
调用栈信息	异常包含完整的调用栈信息	`e.printStackTrace()`

5. 自定义异常

5.1 创建自定义异常类

自定义异常类允许开发者创建特定于应用程序的异常类型。

5.1.1 基本自定义异常

基本自定义异常类

java

1// 继承Exception创建检查型异常
2public class BusinessException extends Exception {
3    private String errorCode;
4    
5    // 默认构造函数
6    public BusinessException() {
7        super();
8    }
9    
10    // 带消息的构造函数
11    public BusinessException(String message) {
12        super(message);
13    }
14    
15    // 带消息和原因的构造函数
16    public BusinessException(String message, Throwable cause) {
17        super(message, cause);
18    }
19    
20    // 带错误代码的构造函数
21    public BusinessException(String message, String errorCode) {
22        super(message);
23        this.errorCode = errorCode;
24    }
25    
26    // 获取错误代码
27    public String getErrorCode() {
28        return errorCode;
29    }
30}
31
32// 继承RuntimeException创建运行时异常
33public class ValidationException extends RuntimeException {
34    private String fieldName;
35    
36    public ValidationException(String message) {
37        super(message);
38    }
39    
40    public ValidationException(String message, String fieldName) {
41        super(message);
42        this.fieldName = fieldName;
43    }
44    
45    public ValidationException(String message, Throwable cause) {
46        super(message, cause);
47    }
48    
49    public String getFieldName() {
50        return fieldName;
51    }
52}

5.1.2 使用自定义异常

使用自定义异常

java

1public class CustomExceptionDemo {
2    public static void main(String[] args) {
3        try {
4            // 测试业务异常
5            processOrder("INVALID_ORDER");
6            
7        } catch (BusinessException e) {
8            System.err.println("业务异常: " + e.getMessage());
9            System.err.println("错误代码: " + e.getErrorCode());
10        }
11        
12        try {
13            // 测试验证异常
14            validateUser("", -1);
15            
16        } catch (ValidationException e) {
17            System.err.println("验证异常: " + e.getMessage());
18            System.err.println("字段名: " + e.getFieldName());
19        }
20    }
21    
22    public static void processOrder(String orderId) throws BusinessException {
23        if ("INVALID_ORDER".equals(orderId)) {
24            throw new BusinessException("无效的订单ID", "ORDER_001");
25        }
26        System.out.println("订单处理成功: " + orderId);
27    }
28    
29    public static void validateUser(String username, int age) {
30        if (username == null || username.trim().isEmpty()) {
31            throw new ValidationException("用户名不能为空", "username");
32        }
33        if (age < 0 || age > 150) {
34            throw new ValidationException("年龄必须在0-150之间", "age");
35        }
36        System.out.println("用户验证通过: " + username + ", " + age);
37    }
38}

5.2 异常链（Exception Chaining）

异常链允许将一个异常包装在另一个异常中，保留原始异常的信息。

5.2.1 异常链示例

异常链示例

java

1public class ExceptionChainingDemo {
2    public static void main(String[] args) {
3        try {
4            // 调用可能抛出异常的方法
5            processData();
6            
7        } catch (BusinessException e) {
8            System.err.println("业务异常: " + e.getMessage());
9            // 打印原因异常
10            if (e.getCause() != null) {
11                System.err.println("原因: " + e.getCause().getMessage());
12                e.getCause().printStackTrace();
13            }
14        }
15    }
16    
17    public static void processData() throws BusinessException {
18        try {
19            // 模拟底层操作
20            performLowLevelOperation();
21            
22        } catch (IOException e) {
23            // 将底层异常包装为业务异常
24            throw new BusinessException("数据处理失败", e);
25        }
26    }
27    
28    private static void performLowLevelOperation() throws IOException {
29        // 模拟IO异常
30        throw new IOException("底层IO操作失败");
31    }
32}

6. 异常处理最佳实践

6.1 异常处理原则

6.1.1 只捕获能处理的异常

只捕获能处理的异常

java

1public class ExceptionHandlingPrinciples {
2    public static void main(String[] args) {
3        // 好的做法：只捕获能处理的异常
4        try {
5            readConfiguration();
6        } catch (IOException e) {
7            // 可以处理：使用默认配置
8            System.out.println("使用默认配置");
9            loadDefaultConfiguration();
10        }
11        
12        // 避免：捕获所有异常但不处理
13        try {
14            processData();
15        } catch (Exception e) {
16            // 不好的做法：捕获所有异常但不处理
17            e.printStackTrace();
18            // 应该根据异常类型进行相应处理
19        }
20    }
21    
22    private static void readConfiguration() throws IOException {
23        // 读取配置文件
24        throw new IOException("配置文件读取失败");
25    }
26    
27    private static void loadDefaultConfiguration() {
28        System.out.println("加载默认配置");
29    }
30    
31    private static void processData() {
32        // 处理数据
33    }
34}

6.1.2 使用具体的异常类型

使用具体的异常类型

java

1public class SpecificExceptionHandling {
2    public static void main(String[] args) {
3        try {
4            // 可能抛出多种异常的操作
5            performOperation();
6            
7        } catch (FileNotFoundException e) {
8            // 处理文件未找到
9            System.err.println("文件未找到，创建新文件");
10            createNewFile();
11            
12        } catch (IOException e) {
13            // 处理其他IO异常
14            System.err.println("IO错误: " + e.getMessage());
15            
16        } catch (SQLException e) {
17            // 处理数据库异常
18            System.err.println("数据库错误: " + e.getMessage());
19            
20        } catch (Exception e) {
21            // 处理其他未知异常
22            System.err.println("未知错误: " + e.getMessage());
23            e.printStackTrace();
24        }
25    }
26    
27    private static void performOperation() throws IOException, SQLException {
28        // 模拟可能抛出多种异常的操作
29        if (Math.random() < 0.3) {
30            throw new FileNotFoundException("配置文件不存在");
31        } else if (Math.random() < 0.6) {
32            throw new IOException("文件读取失败");
33        } else {
34            throw new SQLException("数据库连接失败");
35        }
36    }
37    
38    private static void createNewFile() {
39        System.out.println("创建新配置文件");
40    }
41}

6.2 资源管理最佳实践

6.2.1 使用try-with-resources

资源管理最佳实践

java

1public class ResourceManagementBestPractices {
2    public static void main(String[] args) {
3        // 好的做法：使用try-with-resources
4        try (FileInputStream fis = new FileInputStream("input.txt");
5             FileOutputStream fos = new FileOutputStream("output.txt");
6             BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
7            
8            // 处理文件
9            processFiles(fis, fos, reader);
10            
11        } catch (IOException e) {
12            System.err.println("文件操作错误: " + e.getMessage());
13        }
14        // 资源自动关闭
15    }
16    
17    private static void processFiles(FileInputStream fis, FileOutputStream fos, BufferedReader reader) throws IOException {
18        // 文件处理逻辑
19        String line;
20        while ((line = reader.readLine()) != null) {
21            // 处理每一行
22            System.out.println("处理行: " + line);
23        }
24    }
25}

6.2.2 避免在finally块中抛出异常

避免在finally块中抛出异常

java

1public class FinallyBlockBestPractices {
2    public static void main(String[] args) {
3        try {
4            // 主要操作
5            performMainOperation();
6            
7        } catch (Exception e) {
8            System.err.println("主要操作失败: " + e.getMessage());
9            
10        } finally {
11            // 清理资源，避免抛出异常
12            try {
13                cleanup();
14            } catch (Exception e) {
15                // 记录清理异常，但不抛出
16                System.err.println("清理资源时发生错误: " + e.getMessage());
17                // 可以选择记录日志，但不中断程序
18            }
19        }
20    }
21    
22    private static void performMainOperation() throws Exception {
23        // 模拟主要操作
24        if (Math.random() < 0.5) {
25            throw new Exception("主要操作失败");
26        }
27        System.out.println("主要操作成功");
28    }
29    
30    private static void cleanup() throws Exception {
31        // 模拟清理操作
32        if (Math.random() < 0.3) {
33            throw new Exception("清理操作失败");
34        }
35        System.out.println("清理完成");
36    }
37}

6.3 异常信息记录

6.3.1 记录异常信息

异常信息记录

java

1public class ExceptionLogging {
2    public static void main(String[] args) {
3        try {
4            // 可能抛出异常的操作
5            riskyOperation();
6            
7        } catch (Exception e) {
8            // 记录异常信息
9            logException(e);
10            
11            // 根据异常类型进行相应处理
12            handleException(e);
13        }
14    }
15    
16    private static void riskyOperation() throws Exception {
17        // 模拟可能抛出异常的操作
18        if (Math.random() < 0.5) {
19            throw new Exception("随机错误");
20        }
21        System.out.println("操作成功");
22    }
23    
24    private static void logException(Exception e) {
25        // 记录异常信息到日志系统
26        System.err.println("=== 异常信息 ===");
27        System.err.println("异常类型: " + e.getClass().getSimpleName());
28        System.err.println("异常消息: " + e.getMessage());
29        System.err.println("异常时间: " + new java.util.Date());
30        System.err.println("异常堆栈:");
31            e.printStackTrace();
32        System.err.println("================");
33    }
34    
35    private static void handleException(Exception e) {
36        // 根据异常类型进行相应处理
37        if (e instanceof IOException) {
38            System.err.println("处理IO异常");
39        } else if (e instanceof SQLException) {
40            System.err.println("处理数据库异常");
41        } else {
42            System.err.println("处理其他异常");
43        }
44    }
45}

7. 常见异常处理模式

7.1 重试模式

当操作失败时，自动重试几次以提高成功率。

重试模式示例

java

1public class RetryPattern {
2    public static void main(String[] args) {
3        try {
4            // 使用重试模式执行操作
5            String result = executeWithRetry(() -> riskyOperation(), 3);
6            System.out.println("操作成功: " + result);
7            
8        } catch (Exception e) {
9            System.err.println("所有重试都失败了: " + e.getMessage());
10        }
11    }
12    
13    // 重试模式的核心方法
14    public static <T> T executeWithRetry(Supplier<T> operation, int maxRetries) throws Exception {
15        Exception lastException = null;
16        
17        for (int attempt = 1; attempt <= maxRetries; attempt++) {
18            try {
19                System.out.println("尝试第 " + attempt + " 次");
20                return operation.get();
21                
22            } catch (Exception e) {
23                lastException = e;
24                System.err.println("第 " + attempt + " 次尝试失败: " + e.getMessage());
25                
26                if (attempt < maxRetries) {
27                    // 等待一段时间后重试
28                    try {
29                        Thread.sleep(1000 * attempt); // 递增等待时间
30                    } catch (InterruptedException ie) {
31                        Thread.currentThread().interrupt();
32                        throw new RuntimeException("重试被中断", ie);
33                    }
34                }
35            }
36        }
37        
38        throw lastException;
39    }
40    
41    private static String riskyOperation() throws Exception {
42        // 模拟可能失败的操作
43        if (Math.random() < 0.7) {
44            throw new Exception("操作失败");
45        }
46        return "操作成功";
47    }
48}

7.2 熔断器模式

当系统出现问题时，暂时停止服务以避免级联故障。

熔断器模式示例

java

1public class CircuitBreakerPattern {
2    private static class CircuitBreaker {
3        private enum State { CLOSED, OPEN, HALF_OPEN }
4        
5        private State state = State.CLOSED;
6        private int failureCount = 0;
7        private int threshold = 3;
8        private long lastFailureTime = 0;
9        private long timeout = 5000; // 5秒超时
10        
11        public synchronized boolean canExecute() {
12            if (state == State.OPEN) {
13                if (System.currentTimeMillis() - lastFailureTime > timeout) {
14                    state = State.HALF_OPEN;
15                    return true;
16                }
17                return false;
18            }
19            return true;
20        }
21        
22        public synchronized void recordSuccess() {
23            failureCount = 0;
24            state = State.CLOSED;
25        }
26        
27        public synchronized void recordFailure() {
28            failureCount++;
29            lastFailureTime = System.currentTimeMillis();
30            
31            if (failureCount >= threshold) {
32                state = State.OPEN;
33            }
34        }
35        
36        public State getState() {
37            return state;
38        }
39    }
40    
41    private static CircuitBreaker circuitBreaker = new CircuitBreaker();
42    
43    public static void main(String[] args) {
44        for (int i = 0; i < 10; i++) {
45            try {
46                if (circuitBreaker.canExecute()) {
47                    String result = riskyOperation();
48                    System.out.println("操作成功: " + result);
49                    circuitBreaker.recordSuccess();
50                } else {
51                    System.out.println("熔断器开启，跳过操作");
52                }
53                
54                Thread.sleep(1000);
55                
56            } catch (Exception e) {
57                System.err.println("操作失败: " + e.getMessage());
58                circuitBreaker.recordFailure();
59            }
60        }
61    }
62    
63    private static String riskyOperation() throws Exception {
64        // 模拟可能失败的操作
65        if (Math.random() < 0.8) {
66            throw new Exception("操作失败");
67        }
68        return "操作成功";
69    }
70}

7.3 优雅降级模式

当主要功能失败时，提供备选方案以保持系统可用性。

优雅降级模式示例

java

1public class GracefulDegradationPattern {
2    public static void main(String[] args) {
3        // 尝试主要功能，失败时使用备选方案
4        String result = executeWithFallback(
5            () -> primaryOperation(),
6            () -> fallbackOperation()
7        );
8        
9        System.out.println("最终结果: " + result);
10    }
11    
12    public static <T> T executeWithFallback(Supplier<T> primary, Supplier<T> fallback) {
13        try {
14            return primary.get();
15        } catch (Exception e) {
16            System.err.println("主要操作失败，使用备选方案: " + e.getMessage());
17            try {
18                return fallback.get();
19            } catch (Exception fallbackException) {
20                System.err.println("备选方案也失败了: " + fallbackException.getMessage());
21                return getDefaultValue();
22            }
23        }
24    }
25    
26    private static String primaryOperation() throws Exception {
27        // 模拟主要功能
28        if (Math.random() < 0.7) {
29            throw new Exception("主要功能暂时不可用");
30        }
31        return "主要功能结果";
32    }
33    
34    private static String fallbackOperation() throws Exception {
35        // 模拟备选功能
36        if (Math.random() < 0.3) {
37            throw new Exception("备选功能也失败了");
38        }
39        return "备选功能结果";
40    }
41    
42    private static String getDefaultValue() {
43        return "默认值";
44    }
45}

8. 面试题精选

8.1 基础概念题

Q: 什么是Java异常？异常和错误的区别是什么？

A: Java异常是程序执行期间发生的事件，它会中断程序指令的正常流程。异常和错误的区别：

Exception（异常）：通常表示程序可以处理的错误情况，如文件不存在、网络连接失败等
Error（错误）：表示严重的问题，程序通常无法恢复，如内存不足、栈溢出等
处理方式：Exception应该被捕获和处理，Error通常不需要也不应该捕获

Q: 检查型异常和运行时异常的区别是什么？

检查型异常（Checked Exception）：编译器强制要求处理的异常，如IOException、SQLException等。必须在代码中显式处理或声明抛出
运行时异常（Runtime Exception）：编译器不强制要求处理的异常，如NullPointerException、ArrayIndexOutOfBoundsException等。通常表示编程错误，应该在开发阶段避免

8.2 异常处理题

Q: try-catch-finally的执行顺序是什么？

A: try-catch-finally的执行顺序：

try块：执行可能抛出异常的代码
catch块：如果发生异常，执行相应的异常处理代码
finally块：无论是否发生异常，都会执行清理代码
特殊情况：如果在try或catch块中执行了System.exit()，finally块不会执行

Q: 什么情况下finally块不会执行？

A: finally块不会执行的情况：

在try或catch块中调用了System.exit()
JVM崩溃或进程被强制终止
在try或catch块中调用了System.halt()
线程被强制终止

8.3 实践题

Q: 设计一个异常处理框架，支持异常分类和统一处理

java

1public class ExceptionHandler {
2    private Map<Class<? extends Exception>, ExceptionProcessor> processors = new HashMap<>();
3    
4    public void registerProcessor(Class<? extends Exception> exceptionType, ExceptionProcessor processor) {
5        processors.put(exceptionType, processor);
6    }
7    
8    public void handleException(Exception e) {
9        ExceptionProcessor processor = processors.get(e.getClass());
10        if (processor != null) {
11            processor.process(e);
12        } else {
13            // 默认处理
14            System.err.println("未处理的异常: " + e.getMessage());
15            e.printStackTrace();
16        }
17    }
18    
19    public interface ExceptionProcessor {
20        void process(Exception e);
21    }
22    
23    // 使用示例
24    public static void main(String[] args) {
25        ExceptionHandler handler = new ExceptionHandler();
26        
27        // 注册异常处理器
28        handler.registerProcessor(IOException.class, e -> {
29            System.err.println("处理IO异常: " + e.getMessage());
30        });
31        
32        handler.registerProcessor(SQLException.class, e -> {
33            System.err.println("处理数据库异常: " + e.getMessage());
34        });
35        
36        // 处理异常
37        try {
38            throw new IOException("文件读取失败");
39        } catch (Exception e) {
40            handler.handleException(e);
41        }
42    }
43}

Q: 实现一个方法，安全地关闭多个资源

java

1public class ResourceCloser {
2  public static void closeResources(AutoCloseable... resources) {
3      List<Exception> exceptions = new ArrayList<>();
4      
5      for (AutoCloseable resource : resources) {
6          if (resource != null) {
7              try {
8                  resource.close();
9              } catch (Exception e) {
10                  exceptions.add(e);
11              }
12          }
13      }
14      
15      // 如果有多个异常，抛出第一个
16      if (!exceptions.isEmpty()) {
17          throw new RuntimeException("关闭资源时发生错误", exceptions.get(0));
18      }
19  }
20  
21  // 使用示例
22  public static void main(String[] args) {
23      try (FileInputStream fis = new FileInputStream("input.txt");
24           FileOutputStream fos = new FileOutputStream("output.txt")) {
25          
26          // 使用资源
27          System.out.println("资源使用中...");
28          
29      } catch (Exception e) {
30          System.err.println("操作失败: " + e.getMessage());
31      }
32      // 资源自动关闭
33  }
34}

8.4 高级面试题

Q: 如何设计一个支持国际化错误信息的异常系统？

java

1public class InternationalizedException extends Exception {
2    private String errorCode;
3    private Object[] parameters;
4    
5    public InternationalizedException(String errorCode, Object... parameters) {
6        super(getLocalizedMessage(errorCode, parameters));
7        this.errorCode = errorCode;
8        this.parameters = parameters;
9    }
10    
11    private static String getLocalizedMessage(String errorCode, Object... parameters) {
12        // 从资源文件获取本地化消息
13        ResourceBundle bundle = ResourceBundle.getBundle("error-messages", Locale.getDefault());
14        String pattern = bundle.getString(errorCode);
15        return MessageFormat.format(pattern, parameters);
16    }
17    
18    public String getErrorCode() {
19        return errorCode;
20    }
21    
22    public Object[] getParameters() {
23        return parameters;
24    }
25}
26
27// 使用示例
28public class I18nExceptionDemo {
29    public static void main(String[] args) {
30        try {
31            throw new InternationalizedException("USER_NOT_FOUND", "张三");
32        } catch (InternationalizedException e) {
33            System.err.println("错误代码: " + e.getErrorCode());
34            System.err.println("错误消息: " + e.getMessage());
35        }
36    }
37}

Q: 如何实现异常的性能监控和统计？

java

1public class ExceptionMonitor {
2    private static final Map<String, AtomicInteger> exceptionCounts = new ConcurrentHashMap<>();
3    private static final Map<String, Long> lastOccurrence = new ConcurrentHashMap<>();
4    
5    public static void recordException(Exception e) {
6        String exceptionType = e.getClass().getSimpleName();
7        
8        // 增加计数
9        exceptionCounts.computeIfAbsent(exceptionType, k -> new AtomicInteger(0))
10                      .incrementAndGet();
11        
12        // 记录最后出现时间
13        lastOccurrence.put(exceptionType, System.currentTimeMillis());
14        
15        // 记录到日志系统
16        logException(e);
17    }
18    
19    public static void printStatistics() {
20        System.out.println("=== 异常统计 ===");
21        exceptionCounts.forEach((type, count) -> {
22            long lastTime = lastOccurrence.getOrDefault(type, 0L);
23            String lastTimeStr = lastTime > 0 ? new Date(lastTime).toString() : "从未";
24            System.out.printf("%s: %d次, 最后出现: %s%n", type, count.get(), lastTimeStr);
25        });
26    }
27    
28    private static void logException(Exception e) {
29        // 记录到日志系统
30        System.err.println("记录异常: " + e.getClass().getSimpleName() + " - " + e.getMessage());
31    }
32}

9. 总结

核心要点
学习建议
进阶方向
Do's & Don'ts

异常体系结构：理解Exception、Error的区别，掌握检查型异常和运行时异常的特点
异常处理机制：熟练使用try-catch-finally、try-with-resources等语句
异常传播：理解异常的向上传播机制和调用栈信息
自定义异常：能够创建适合业务需求的异常类型
最佳实践：遵循异常处理的原则和模式

通过本章的学习，你应该已经掌握了Java异常处理的核心概念、机制和最佳实践。异常处理是Java编程中非常重要的技能，良好的异常处理能够提高程序的健壮性和用户体验。在实际开发中，要根据具体的业务场景选择合适的异常处理策略，并遵循最佳实践原则。

记住：异常处理不是万能的，但良好的异常处理能让程序更加健壮和可靠。

1. 异常基础概念​

1.1 什么是异常？​

1.2 异常处理的优点​

1.3 异常处理的基本流程​

2. Java异常体系结构​

2.1 异常层次结构​

常见异常类型示例

Error示例

检查型异常示例

运行时异常示例

2.2 异常分类详解​

2.2.1 检查型异常（Checked Exception）​

2.2.2 运行时异常（Runtime Exception）​

2.2.3 错误（Error）​

3. 异常处理机制​

3.1 try-catch-finally 语句​

try-catch-finally执行流程

3.1.2 详细示例​

3.2 多重异常捕获​

3.2.1 传统方式​

3.2.2 多重异常捕获（Java 7+）​

3.3 try-with-resources 语句​

3.3.1 传统资源管理​

3.3.2 try-with-resources 方式​

3.3.3 自定义AutoCloseable资源​

4. 异常抛出与传播​

4.1 throw 语句​

4.1.1 基本语法​

4.1.2 详细示例​

4.2 throws 关键字​

4.2.1 基本语法​

4.2.2 详细示例​

4.3 异常传播机制​

4.3.1 异常传播示例​

4.3.2 异常传播的特点​

5. 自定义异常​

5.1 创建自定义异常类​

5.1.1 基本自定义异常​

5.1.2 使用自定义异常​

5.2 异常链（Exception Chaining）​

5.2.1 异常链示例​

6. 异常处理最佳实践​

6.1 异常处理原则​

6.1.1 只捕获能处理的异常​

6.1.2 使用具体的异常类型​

6.2 资源管理最佳实践​

6.2.1 使用try-with-resources​

6.2.2 避免在finally块中抛出异常​

6.3 异常信息记录​

6.3.1 记录异常信息​

7. 常见异常处理模式​

7.1 重试模式​

7.2 熔断器模式​

7.3 优雅降级模式​

8. 面试题精选​

8.1 基础概念题​

8.2 异常处理题​

8.3 实践题​

8.4 高级面试题​

9. 总结​

异常处理核心要点

学习路径建议

学习阶段

1. 异步异常处理

2. 响应式编程

3. 微服务架构

4. 性能优化

✓ Do

✗ Don't

参与讨论

1. 异常基础概念

1.1 什么是异常？

1.2 异常处理的优点

1.3 异常处理的基本流程

2. Java异常体系结构

2.1 异常层次结构

2.2 异常分类详解

2.2.1 检查型异常（Checked Exception）

2.2.2 运行时异常（Runtime Exception）

2.2.3 错误（Error）

3. 异常处理机制

3.1 try-catch-finally 语句

3.1.2 详细示例

3.2 多重异常捕获

3.2.1 传统方式

3.2.2 多重异常捕获（Java 7+）

3.3 try-with-resources 语句

3.3.1 传统资源管理

3.3.2 try-with-resources 方式

3.3.3 自定义AutoCloseable资源

4. 异常抛出与传播

4.1 throw 语句

4.1.1 基本语法

4.1.2 详细示例

4.2 throws 关键字

4.2.1 基本语法

4.2.2 详细示例

4.3 异常传播机制

4.3.1 异常传播示例

4.3.2 异常传播的特点

5. 自定义异常

5.1 创建自定义异常类

5.1.1 基本自定义异常

5.1.2 使用自定义异常

5.2 异常链（Exception Chaining）

5.2.1 异常链示例

6. 异常处理最佳实践

6.1 异常处理原则

6.1.1 只捕获能处理的异常

6.1.2 使用具体的异常类型

6.2 资源管理最佳实践

6.2.1 使用try-with-resources

6.2.2 避免在finally块中抛出异常

6.3 异常信息记录

6.3.1 记录异常信息

7. 常见异常处理模式

7.1 重试模式

7.2 熔断器模式

7.3 优雅降级模式

8. 面试题精选

8.1 基础概念题

8.2 异常处理题

8.3 实践题

8.4 高级面试题

9. 总结