Java 异常处理机制详解

Throwable
├── Error（严重错误，不应捕获）
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── ...
└── Exception（程序可处理）
    ├── RuntimeException（运行时异常）
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   ├── IllegalArgumentException
    │   └── ...
    └── 其他异常（受检异常）
        ├── IOException
        ├── SQLException
        ├── ClassNotFoundException
        └── ...

// 必须处理
public void readFile() throws IOException {
    FileReader reader = new FileReader("file.txt");
}

// 不强制处理，但应该避免
public void divide(int a, int b) {
    int result = a / b;  // 可能抛出 ArithmeticException
}

try {
    // 可能抛出异常的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // 处理异常
    System.out.println("除数不能为0");
}

try {
    // 可能抛出多种异常
    int[] arr = new int[5];
    arr[10] = 100;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("数组越界");
} catch (Exception e) {
    System.out.println("其他异常");
}

FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // 读取文件
} catch (IOException e) {
    e.printStackTrace();
} finally {
    // 一定会执行
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 自动关闭资源
try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
    String line = br.readLine();
    System.out.println(line);
} catch (IOException e) {
    e.printStackTrace();
}
// 自动调用 close()

public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负数");
    }
    this.age = age;
}

// 声明方法可能抛出的异常
public void readFile(String path) throws FileNotFoundException, IOException {
    FileReader reader = new FileReader(path);
    reader.read();
}

// 自定义受检异常
public class BusinessException extends Exception {
    private String errorCode;

    public BusinessException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }

    public String getErrorCode() {
        return errorCode;
    }
}

// 自定义运行时异常
public class ValidationException extends RuntimeException {
    public ValidationException(String message) {
        super(message);
    }

    public ValidationException(String message, Throwable cause) {
        super(message, cause);
    }
}

public void transfer(Account from, Account to, BigDecimal amount) 
        throws BusinessException {
    if (from.getBalance().compareTo(amount) < 0) {
        throw new BusinessException("E001", "余额不足");
    }
    // 转账逻辑
}

try {
    readFile();
} catch (IOException e) {
    // 包装异常，保留原始信息
    throw new ServiceException("文件读取失败", e);
}

// 错误
try {
    // ...
} catch (Throwable t) {  // 不要这样做！
    // ...
}

// 正确
try {
    // ...
} catch (SpecificException e) {
    // ...
}

// 错误
try {
    doSomething();
} catch (Exception e) {
    // 空的 catch 块！
}

// 正确
try {
    doSomething();
} catch (Exception e) {
    logger.error("操作失败", e);
    // 或抛出
    throw new RuntimeException("操作失败", e);
}

// 在底层抛出具体异常
public void parseInt(String str) {
    if (str == null || str.isEmpty()) {
        throw new IllegalArgumentException("字符串不能为空");
    }
    // ...
}

// 在高层统一处理
public void process() {
    try {
        parseInt(input);
        doSomethingElse();
    } catch (IllegalArgumentException e) {
        // 统一处理参数错误
        showError(e.getMessage());
    }
}

// 不好
throw new IllegalArgumentException("error");

// 好
throw new IllegalArgumentException("用户ID不能为空");

// 更好
throw new IllegalArgumentException("用户ID不能为空，当前值: " + userId);

// 避免 NullPointerException
Optional<String> optional = Optional.ofNullable(getString());

// 取值
String value = optional.orElse("default");
String value2 = optional.orElseThrow(() -> new NotFoundException("未找到"));

// 链式操作
optional.filter(s -> s.length() > 0)
        .map(String::toUpperCase)
        .ifPresent(System.out::println);