编辑“︁Java异常体系”︁（章节）

= Java异常体系 =

== 概述 ==
Java异常体系是Java语言中用于处理程序运行时错误的机制框架。当程序在运行过程中出现意外情况（如除以零、空指针访问等）时，Java会'''抛出(throw)'''一个异常对象，程序可以'''捕获(catch)'''并处理这个异常，从而保证程序的健壮性。

Java异常体系的核心特点是：
* '''继承层次结构'''：所有异常类型都是<code>java.lang.Throwable</code>的子类
* '''分类处理'''：分为检查型异常(Checked Exception)和非检查型异常(Unchecked Exception)
* '''传播机制'''：异常会沿着方法调用栈向上传播，直到被捕获或导致程序终止

== 异常分类 ==
Java异常体系主要分为三大类：

<mermaid>
classDiagram
    Throwable <|-- Error
    Throwable <|-- Exception
    Exception <|-- RuntimeException
    Exception <|-- IOException
</mermaid>

=== 1. Error ===
表示JVM本身的严重错误，应用程序通常无法处理。例如：
* <code>OutOfMemoryError</code>
* <code>StackOverflowError</code>
* <code>VirtualMachineError</code>

=== 2. 检查型异常(Checked Exception) ===
继承自<code>Exception</code>但不属于<code>RuntimeException</code>的异常，编译器会强制检查。常见例子：
* <code>IOException</code>
* <code>SQLException</code>
* <code>ClassNotFoundException</code>

=== 3. 非检查型异常(Unchecked Exception) ===
继承自<code>RuntimeException</code>的异常，编译器不强制处理。常见例子：
* <code>NullPointerException</code>
* <code>ArrayIndexOutOfBoundsException</code>
* <code>IllegalArgumentException</code>

== 异常处理机制 ==
Java通过五个关键字实现异常处理：<code>try</code>, <code>catch</code>, <code>finally</code>, <code>throw</code>, <code>throws</code>

=== 基本语法 ===
<syntaxhighlight lang="java">
try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 无论是否发生异常都会执行的代码
}
</syntaxhighlight>

=== 示例：文件读取 ===
<syntaxhighlight lang="java">
import java.io.*;

public class FileExample {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("test.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("IO错误: " + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                System.err.println("关闭文件时出错: " + e.getMessage());
            }
        }
    }
}
</syntaxhighlight>

'''可能的输出：'''
<pre>
文件未找到: test.txt (系统找不到指定的文件。)
</pre>

== 自定义异常 ==
可以创建自己的异常类来代表特定问题：

<syntaxhighlight lang="java">
// 自定义检查型异常
class InsufficientFundsException extends Exception {
    private double amount;
    
    public InsufficientFundsException(double amount) {
        super("资金不足，缺少: " + amount);
        this.amount = amount;
    }
    
    public double getAmount() {
        return amount;
    }
}

// 使用示例
class BankAccount {
    private double balance;
    
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException(amount - balance);
        }
        balance -= amount;
    }
}
</syntaxhighlight>

== 最佳实践 ==
1. '''具体异常优先'''：捕获最具体的异常类型，而不是直接捕获<code>Exception</code>
2. '''不要忽略异常'''：至少记录异常信息
3. '''合理使用finally'''：释放资源应放在finally块中
4. '''避免空的catch块'''：这会隐藏错误
5. '''异常与业务逻辑分离'''：不要用异常控制正常流程

== 异常链 ==
Java支持异常链，可以将底层异常包装为高层异常：

<syntaxhighlight lang="java">
try {
    // 可能抛出SQLException的代码
} catch (SQLException e) {
    throw new ServiceException("数据库操作失败", e);
}
</syntaxhighlight>

== 性能考虑 ==
异常处理会带来性能开销，特别是在频繁执行的代码路径中。对于可预见的错误条件，考虑使用返回值而不是异常。

异常实例的构造开销主要来自：
* 填充异常栈轨迹（可通过重写<code>fillInStackTrace()</code>优化）
* 异常对象的创建本身

== 数学表示 ==
异常处理的概率模型可以表示为：

<math>
P(程序终止) = \prod_{i=1}^{n} (1 - P(处理异常_i))
</math>

其中<math>P(处理异常_i)</math>表示第i层异常被处理的概率。

== 实际案例 ==
'''电商系统库存检查'''：
<syntaxhighlight lang="java">
public class InventoryService {
    public void reserveItem(String itemId, int quantity) 
            throws InventoryException {
        try {
            // 检查库存
            int available = checkInventoryDB(itemId);
            if (available < quantity) {
                throw new InventoryException(
                    "库存不足，请求: " + quantity + 
                    ", 可用: " + available);
            }
            // 更新库存...
        } catch (SQLException e) {
            throw new InventoryException("数据库访问失败", e);
        }
    }
}
</syntaxhighlight>

== 常见面试问题 ==
1. Error和Exception的区别是什么？
2. 检查型异常和非检查型异常的主要区别？
3. finally块在什么情况下不会执行？
4. 解释异常链的概念及其用途
5. 为什么不应该用异常来控制程序流程？

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:Java基础]]