异常处理

public class ThrowableMethods {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("getMessage(): " + e.getMessage());
            System.out.println("toString(): " + e.toString());
            System.out.println("\nprintStackTrace():");
            e.printStackTrace();
        }
    }
}

getMessage(): / by zero
toString(): java.lang.ArithmeticException: / by zero

printStackTrace():
java.lang.ArithmeticException: / by zero
    at ThrowableMethods.main(ThrowableMethods.java:4)

// StackOverflowError 示例
public class StackOverflowExample {
    public static void main(String[] args) {
        recursiveMethod();
    }
    
    static void recursiveMethod() {
        recursiveMethod(); // 无限递归,导致 StackOverflowError
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        // 必须处理 FileNotFoundException,否则编译错误
        try {
            FileInputStream fis = new FileInputStream("nonexistent.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }
}

public class UncheckedExceptionExample {
    public static void main(String[] args) {
        // 不需要显式处理,编译器不强制要求
        String str = null;
        System.out.println(str.length()); // 抛出 NullPointerException
    }
}

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e) {
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e) {
    // 处理 ExceptionType2 类型的异常
} finally {
    // 无论是否发生异常都会执行的代码
}

public class TryBlockExample {
    public static void main(String[] args) {
        try {
            System.out.println("Step 1");
            int result = 10 / 0; // 抛出 ArithmeticException
            System.out.println("Step 2"); // 不会执行
        } catch (ArithmeticException e) {
            System.out.println("Step 3: Caught exception");
        }
        System.out.println("Step 4: Continue");
    }
}

Step 1
Step 3: Caught exception
Step 4: Continue

// √ 正确:子类异常在前
try {
    // ...
} catch (NullPointerException e) {
    // 处理空指针异常
} catch (RuntimeException e) {
    // 处理运行时异常
} catch (Exception e) {
    // 处理其他异常
}

// × 错误:父类异常在前,子类异常永远不会被捕获
try {
    // ...
} catch (Exception e) {
    // ...
} catch (NullPointerException e) { // 编译错误:不可达代码
    // ...
}

// 使用 | 捕获多种异常类型
try {
    // ...
} catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught: " + e.getClass().getSimpleName());
    // 注意:e 是 final 的,不能重新赋值
}

public class FinallyExecution {
    public static void main(String[] args) {
        System.out.println("Result: " + test());
    }
    
    static String test() {
        try {
            System.out.println("Try block");
            return "Return from try";
        } catch (Exception e) {
            System.out.println("Catch block");
            return "Return from catch";
        } finally {
            System.out.println("Finally block (always executes)");
        }
    }
}

Try block
Finally block (always executes)
Result: Return from try

public class FinallyReturn {
    public static void main(String[] args) {
        System.out.println("Test 1: " + test1()); // 返回 20
        System.out.println("Test 2: " + test2()); // 返回 20
    }
    
    // finally 中的 return 会覆盖 try 中的 return
    static int test1() {
        try {
            return 10;
        } finally {
            return 20; // 不推荐:覆盖了 try 的返回值
        }
    }
    
    // finally 中修改基本类型不影响返回值
    static int test2() {
        int x = 10;
        try {
            return x;
        } finally {
            x = 20; // 不影响返回值,因为已经保存了副本
        }
    }
}

        进入 try 块
             │
             ▼
    try 块是否抛出异常?
        /          \
      否            是
       │             │
       ▼             ▼
   执行 finally   是否有匹配的 catch?
       │           /          \
       │         是            否
       │          │             │
       │          ▼             ▼
       │      catch 处理    执行 finally
       │          │             │
       │          ▼             ▼
       │      执行 finally   异常继续传播
       │          │
       ▼          ▼
      程序继续执行

public class TryCatchFinallyFlow {
    public static void main(String[] args) {
        System.out.println("=== Scenario 1: No exception ===");
        testScenario1();
        
        System.out.println("\n=== Scenario 2: Exception caught ===");
        testScenario2();
        
        System.out.println("\n=== Scenario 3: Exception not caught ===");
        try {
            testScenario3();
        } catch (Exception e) {
            System.out.println("Caught in main: " + e.getClass().getSimpleName());
        }
    }
    
    static void testScenario1() {
        try {
            System.out.println("Try: executing");
        } catch (Exception e) {
            System.out.println("Catch: handling exception");
        } finally {
            System.out.println("Finally: always executes");
        }
        System.out.println("After try-catch-finally");
    }
    
    static void testScenario2() {
        try {
            System.out.println("Try: throwing exception");
            throw new RuntimeException("Test exception");
        } catch (RuntimeException e) {
            System.out.println("Catch: handling exception");
        } finally {
            System.out.println("Finally: always executes");
        }
        System.out.println("After try-catch-finally");
    }
    
    static void testScenario3() {
        try {
            System.out.println("Try: throwing exception");
            throw new Exception("Test exception");
        } finally {
            System.out.println("Finally: always executes (exception not caught)");
        }
        // 这里不会执行,因为异常未被捕获
    }
}

public class ThrowExample {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (IllegalArgumentException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
    
    static void validateAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        if (age < 18) {
            throw new IllegalArgumentException("Age must be at least 18");
        }
        System.out.println("Age is valid: " + age);
    }
}

import java.io.IOException;

public class ThrowCheckedException {
    public static void main(String[] args) {
        try {
            readFile(null);
        } catch (IOException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
    
    // 必须声明 throws IOException
    static void readFile(String fileName) throws IOException {
        if (fileName == null) {
            throw new IOException("File name cannot be null");
        }
        // 读取文件...
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ThrowsExample {
    public static void main(String[] args) {
        try {
            method1();
        } catch (IOException e) {
            System.out.println("Caught in main: " + e.getMessage());
        }
    }
    
    // 声明可能抛出 IOException
    static void method1() throws IOException {
        method2();
    }
    
    // 声明多个异常
    static void method2() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("file.txt");
        fis.read();
    }
}

import java.io.IOException;

public class ThrowVsThrows {
    public static void main(String[] args) {
        try {
            methodWithThrows();
            methodWithThrow();
        } catch (IOException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
    
    // throws:声明异常,不处理
    static void methodWithThrows() throws IOException {
        System.out.println("Method with throws");
        // 可能抛出 IOException 的操作
    }
    
    // throw:主动抛出异常
    static void methodWithThrow() throws IOException {
        System.out.println("Method with throw");
        throw new IOException("Manually thrown exception");
        // 这里的代码不会执行
    }
}

import java.io.FileInputStream;
import java.io.IOException;

public class ResourceManagement {
    public static void main(String[] args) {
        // 传统方式(Java 7 之前)
        traditionalWay();
        
        // try-with-resources 方式(Java 7+)
        modernWay();
    }
    
    static void traditionalWay() {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("file.txt");
            // 使用资源
            int data = fis.read();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 手动关闭资源
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    static void modernWay() {
        // 自动关闭资源
        try (FileInputStream fis = new FileInputStream("file.txt")) {
            int data = fis.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 资源自动关闭,无需 finally
    }
}

try (ResourceType resource = new ResourceType()) {
    // 使用资源
} catch (Exception e) {
    // 处理异常
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class MultipleResources {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 资源按声明顺序的逆序关闭(fos 先关闭,fis 后关闭)
    }
}

public interface AutoCloseable {
    void close() throws Exception;
}

public class CustomResource implements AutoCloseable {
    private String name;
    
    public CustomResource(String name) {
        this.name = name;
        System.out.println(name + " created");
    }
    
    public void doSomething() {
        System.out.println(name + " doing something");
    }
    
    @Override
    public void close() {
        System.out.println(name + " closed");
    }
}

public class CustomResourceExample {
    public static void main(String[] args) {
        try (CustomResource r1 = new CustomResource("Resource1");
             CustomResource r2 = new CustomResource("Resource2")) {
            r1.doSomething();
            r2.doSomething();
        }
        // 输出顺序:
        // Resource1 created
        // Resource2 created
        // Resource1 doing something
        // Resource2 doing something
        // Resource2 closed  (后声明的先关闭)
        // Resource1 closed
    }
}

public class SuppressedException implements AutoCloseable {
    @Override
    public void close() throws Exception {
        throw new Exception("Exception from close()");
    }
    
    public static void main(String[] args) {
        try (SuppressedException se = new SuppressedException()) {
            throw new Exception("Exception from try block");
        } catch (Exception e) {
            System.out.println("Primary exception: " + e.getMessage());
            
            // 获取被抑制的异常
            Throwable[] suppressed = e.getSuppressed();
            for (Throwable t : suppressed) {
                System.out.println("Suppressed exception: " + t.getMessage());
            }
        }
    }
}

Primary exception: Exception from try block
Suppressed exception: Exception from close()

// 自定义受检异常
class InsufficientBalanceException extends Exception {
    private double balance;
    private double amount;
    
    // 无参构造方法
    public InsufficientBalanceException() {
        super("Insufficient balance");
    }
    
    // 带消息的构造方法
    public InsufficientBalanceException(String message) {
        super(message);
    }
    
    // 带详细信息
    public InsufficientBalanceException(double balance, double amount) {
        super(String.format("Insufficient balance: balance=%.2f, withdraw amount=%.2f", 
                           balance, amount));
        this.balance = balance;
        this.amount = amount;
    }
    
    // 带原因异常
    public InsufficientBalanceException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public double getBalance() { return balance; }
    public double getAmount() { return amount; }
}

// 自定义非受检异常
class InvalidAgeException extends RuntimeException {
    private int age;
    
    public InvalidAgeException(int age) {
        super("Invalid age: " + age + ". Age must be between 0 and 150");
        this.age = age;
    }
    
    public InvalidAgeException(String message) {
        super(message);
    }
    
    public int getAge() { return age; }
}

public class BankAccount {
    private String accountNumber;
    private double balance;
    
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }
    
    // 使用自定义受检异常
    public void withdraw(double amount) throws InsufficientBalanceException {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        if (amount > balance) {
            throw new InsufficientBalanceException(balance, amount);
        }
        balance -= amount;
    }
    
    public double getBalance() {
        return balance;
    }
}

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        setAge(age);
    }
    
    // 使用自定义非受检异常
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new InvalidAgeException(age);
        }
        this.age = age;
    }
    
    public int getAge() { return age; }
}

// 使用示例
public class CustomExceptionExample {
    public static void main(String[] args) {
        // 处理受检异常
        BankAccount account = new BankAccount("12345", 1000.0);
        try {
            account.withdraw(1500.0);
        } catch (InsufficientBalanceException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("Available balance: " + e.getBalance());
        }
        
        // 处理非受检异常(可选)
        try {
            Person person = new Person("Alice", 200);
        } catch (InvalidAgeException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

/**
 * 业务异常基类
 */
public class BusinessException extends RuntimeException {
    
    private final String errorCode;
    private final String errorMessage;
    
    public BusinessException(String errorCode, String errorMessage) {
        super(errorMessage);
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }
    
    public BusinessException(String errorCode, String errorMessage, Throwable cause) {
        super(errorMessage, cause);
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }
    
    public String getErrorCode() {
        return errorCode;
    }
    
    public String getErrorMessage() {
        return errorMessage;
    }
}

/**
 * 库存不足异常
 */
public class InsufficientStockException extends BusinessException {
    
    public InsufficientStockException(String productId, int required, int available) {
        super("INSUFFICIENT_STOCK", 
              String.format("商品 %s 库存不足,需要 %d,可用 %d", productId, required, available));
    }
}

/**
 * 余额不足异常
 */
public class InsufficientBalanceException extends BusinessException {
    
    public InsufficientBalanceException(BigDecimal required, BigDecimal available) {
        super("INSUFFICIENT_BALANCE", 
              String.format("余额不足,需要 %s,可用 %s", required, available));
    }
}

/**
 * 业务错误码枚举
 */
public enum ErrorCode {
    
    // 用户相关错误 (1000-1999)
    USER_NOT_FOUND("1001", "用户不存在"),
    USER_ALREADY_EXISTS("1002", "用户已存在"),
    INVALID_PASSWORD("1003", "密码错误"),
    
    // 商品相关错误 (2000-2999)
    PRODUCT_NOT_FOUND("2001", "商品不存在"),
    INSUFFICIENT_STOCK("2002", "库存不足"),
    
    // 订单相关错误 (3000-3999)
    ORDER_NOT_FOUND("3001", "订单不存在"),
    ORDER_ALREADY_PAID("3002", "订单已支付"),
    
    // 通用错误 (9000-9999)
    INVALID_PARAMETER("9001", "参数错误"),
    SYSTEM_ERROR("9999", "系统异常");
    
    private final String code;
    private final String message;
    
    ErrorCode(String code, String message) {
        this.code = code;
        this.message = message;
    }
    
    public String getCode() { return code; }
    public String getMessage() { return message; }
}

/**
 * 统一异常处理器
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    
    /**
     * 处理业务异常
     */
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException e) {
        log.warn("业务异常: {}", e.getMessage());
        
        ErrorResponse response = new ErrorResponse();
        response.setCode(e.getErrorCode());
        response.setMessage(e.getErrorMessage());
        response.setTimestamp(System.currentTimeMillis());
        
        return ResponseEntity.ok().body(response);
    }
    
    /**
     * 处理参数校验异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(MethodArgumentNotValidException e) {
        BindingResult bindingResult = e.getBindingResult();
        String errorMessage = bindingResult.getFieldErrors().stream()
            .map(FieldError::getDefaultMessage)
            .collect(Collectors.joining(", "));
        
        log.warn("参数校验失败: {}", errorMessage);
        
        ErrorResponse response = new ErrorResponse();
        response.setCode("INVALID_PARAMETER");
        response.setMessage(errorMessage);
        response.setTimestamp(System.currentTimeMillis());
        
        return ResponseEntity.badRequest().body(response);
    }
    
    /**
     * 处理所有未知异常（兜底）
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        log.error("系统异常", e);
        
        ErrorResponse response = new ErrorResponse();
        response.setCode("SYSTEM_ERROR");
        response.setMessage("系统繁忙,请稍后重试");  // 不暴露内部错误
        response.setTimestamp(System.currentTimeMillis());
        
        return ResponseEntity.status(500).body(response);
    }
}

/**
 * 错误响应对象
 */
@Data
public class ErrorResponse {
    private String code;
    private String message;
    private Long timestamp;
    private String traceId;  // 链路追踪ID
}

@Service
public class OrderService {
    
    // × 默认:只对 RuntimeException 和 Error 回滚
    // 如果抛出 IOException,事务不会回滚!
    @Transactional
    public void createOrder1() throws IOException {
        // ...
    }
    
    // √ 推荐:指定回滚异常
    @Transactional(rollbackFor = Exception.class)
    public void createOrder2() throws IOException {
        // 对所有 Exception 回滚
    }
}

@Service
public class OrderService {
    
    // × 错误:异常被吞掉,事务不回滚
    @Transactional
    public void createOrderBad(OrderDTO dto) {
        try {
            orderRepository.save(order);
            productRepository.decreaseStock(dto.getProductId(), dto.getQuantity());
        } catch (Exception e) {
            log.error("创建订单失败", e);
            // 异常被捕获,事务提交!库存可能已扣减但订单未创建
        }
    }
    
    // √ 正确:让异常传播,事务回滚
    @Transactional(rollbackFor = Exception.class)
    public void createOrderGood(OrderDTO dto) {
        orderRepository.save(order);
        productRepository.decreaseStock(dto.getProductId(), dto.getQuantity());
        // 如果发生异常,事务自动回滚
    }
}

try {
    // 底层操作
} catch (LowLevelException e) {
    // 将底层异常包装成高层异常
    throw new HighLevelException("High level error message", e);
}

try {
    // 底层操作
} catch (LowLevelException e) {
    HighLevelException high = new HighLevelException("High level error message");
    high.initCause(e);
    throw high;
}

import java.io.FileInputStream;
import java.io.IOException;

// 自定义业务异常
class ConfigException extends Exception {
    public ConfigException(String message) {
        super(message);
    }
    
    public ConfigException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class ExceptionChainingExample {
    public static void main(String[] args) {
        try {
            loadConfig("config.txt");
        } catch (ConfigException e) {
            System.out.println("Config error: " + e.getMessage());
            
            // 获取原始异常
            Throwable cause = e.getCause();
            if (cause != null) {
                System.out.println("Caused by: " + cause.getClass().getName());
                System.out.println("Cause message: " + cause.getMessage());
            }
            
            // 打印完整堆栈跟踪
            System.out.println("\nFull stack trace:");
            e.printStackTrace();
        }
    }
    
    static void loadConfig(String fileName) throws ConfigException {
        try (FileInputStream fis = new FileInputStream(fileName)) {
            // 读取配置...
        } catch (IOException e) {
            // 将 IOException 包装成 ConfigException,保留原始异常
            throw new ConfigException("Failed to load config file: " + fileName, e);
        }
    }
}

Config error: Failed to load config file: config.txt
Caused by: java.io.FileNotFoundException
Cause message: config.txt (No such file or directory)

Full stack trace:
ConfigException: Failed to load config file: config.txt
    at ExceptionChainingExample.loadConfig(ExceptionChainingExample.java:32)
    at ExceptionChainingExample.main(ExceptionChainingExample.java:15)
Caused by: java.io.FileNotFoundException: config.txt (No such file or directory)
    at java.io.FileInputStream.open0(Native Method)
    at java.io.FileInputStream.open(FileInputStream.java:195)
    at java.io.FileInputStream.<init>(FileInputStream.java:138)
    at ExceptionChainingExample.loadConfig(ExceptionChainingExample.java:30)
    ... 1 more

// × 错误:用异常代替条件判断
try {
    int index = findIndex(array, target);
    return array[index];
} catch (ArrayIndexOutOfBoundsException e) {
    return -1;
}

// √ 正确:使用条件判断
int index = findIndex(array, target);
if (index >= 0 && index < array.length) {
    return array[index];
}
return -1;

// × 错误:捕获过于宽泛
try {
    // ... 多种操作
} catch (Exception e) {
    // 无法区分具体的错误类型
    e.printStackTrace();
}

// √ 正确:捕获特定异常
try {
    // ...
} catch (FileNotFoundException e) {
    // 处理文件未找到
} catch (IOException e) {
    // 处理其他 IO 错误
}

// × 错误:隐藏异常
try {
    importantOperation();
} catch (Exception e) {
    // 空的 catch 块,异常被忽略
}

// √ 正确:记录异常
try {
    importantOperation();
} catch (Exception e) {
    logger.error("Operation failed", e);
    // 或者重新抛出
    throw new RuntimeException("Operation failed", e);
}

// × 传统方式:繁琐且容易出错
FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // 使用资源
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            // 忽略关闭异常
        }
    }
}

// √ 推荐方式:自动管理资源
try (FileInputStream fis = new FileInputStream("file.txt")) {
    // 使用资源
}

// × 错误:异常信息不明确
throw new IllegalArgumentException("Invalid argument");

// √ 正确:提供详细信息
throw new IllegalArgumentException(
    String.format("Age must be between %d and %d, but got %d", 
                  MIN_AGE, MAX_AGE, age));

// × 错误:丢失原始异常
try {
    lowLevelOperation();
} catch (LowLevelException e) {
    throw new HighLevelException("Operation failed"); // 丢失了 cause
}

// √ 正确:保留原始异常
try {
    lowLevelOperation();
} catch (LowLevelException e) {
    throw new HighLevelException("Operation failed", e);
}

// × 错误:延迟检查
public void process(String data) {
    // 复杂的逻辑...
    if (data == null) {
        throw new IllegalArgumentException("Data cannot be null");
    }
    // 更多处理...
}

// √ 正确:尽早检查
public void process(String data) {
    if (data == null) {
        throw new IllegalArgumentException("Data cannot be null");
    }
    // 复杂的逻辑...
}

/**
 * 从文件加载用户数据
 * 
 * @param fileName 文件名
 * @return 用户对象
 * @throws FileNotFoundException 文件不存在
 * @throws IOException 读取文件失败
 * @throws InvalidDataException 数据格式无效
 */
public User loadUser(String fileName) 
        throws FileNotFoundException, IOException, InvalidDataException {
    // ...
}

// × 错误:循环中使用异常
for (int i = 0; i < items.length; i++) {
    try {
        process(items[i]);
    } catch (NullPointerException e) {
        // 跳过 null 元素
    }
}

// √ 正确:使用条件检查
for (int i = 0; i < items.length; i++) {
    if (items[i] != null) {
        process(items[i]);
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExceptionLogging {
    private static final Logger logger = LoggerFactory.getLogger(ExceptionLogging.class);
    
    public void process(String data) {
        try {
            doProcess(data);
        } catch (IllegalArgumentException e) {
            // 业务异常,记录警告
            logger.warn("Invalid input data: {}", data, e);
        } catch (IOException e) {
            // 系统异常,记录错误
            logger.error("IO error while processing data", e);
            throw new RuntimeException("Processing failed", e);
        }
    }
}

// × 错误:捕获所有异常
try {
    // ...
} catch (Throwable t) {
    // 捕获了 Error,这是严重错误,不应捕获
}

// √ 正确:只捕获能处理的异常
try {
    // ...
} catch (IOException e) {
    // 处理 IO 错误
}

try {
    System.exit(0); // finally 不会执行
} finally {
    System.out.println("This won't be printed");
}

// × 信息不足
throw new IllegalArgumentException("Invalid port");

// √ 包含上下文
throw new IllegalArgumentException(
    String.format("Invalid port number: %d. Port must be between %d and %d",
                  port, MIN_PORT, MAX_PORT));

// 这个方法可能抛出 IOException,但不一定会抛出
public void readFile(String fileName) throws IOException {
    if (fileName != null) {
        // 可能抛出 IOException
    }
    // 如果 fileName 为 null,不会抛出 IOException
}

// × 错误:依赖异常进行参数验证
public void setAge(int age) {
    try {
        if (age < 0) {
            throw new Exception("Age cannot be negative");
        }
        this.age = age;
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}

// √ 正确:主动验证参数
public void setAge(int age) {
    if (age < 0 || age > 150) {
        throw new IllegalArgumentException(
            "Invalid age: " + age + ". Age must be between 0 and 150");
    }
    this.age = age;
}

// × 性能差:在循环中使用异常
int sum = 0;
int index = 0;
while (true) {
    try {
        sum += array[index++];
    } catch (ArrayIndexOutOfBoundsException e) {
        break; // 用异常结束循环
    }
}

// √ 性能好:使用条件判断
int sum = 0;
for (int i = 0; i < array.length; i++) {
    sum += array[i];
}

// 对于固定消息的异常,可以考虑重用(但通常不推荐)
private static final IllegalArgumentException INVALID_ARG = 
    new IllegalArgumentException("Invalid argument");

public void method(int value) {
    if (value < 0) {
        throw INVALID_ARG;
    }
}

// × 性能差:频繁调用 printStackTrace()
for (int i = 0; i < 1000; i++) {
    try {
        operation();
    } catch (Exception e) {
        e.printStackTrace(); // 每次都生成堆栈跟踪
    }
}

// √ 性能好:使用日志框架
for (int i = 0; i < 1000; i++) {
    try {
        operation();
    } catch (Exception e) {
        logger.error("Operation failed", e); // 日志框架会优化输出
    }
}

// 正确顺序
try {
    // ...
} catch (NullPointerException e) {  // 子类
    // ...
} catch (RuntimeException e) {      // 父类
    // ...
} catch (Exception e) {             // 最顶层父类
    // ...
}

try {
    operation();
} catch (IOException e) {
    // 处理 IO 异常
} catch (SQLException e) {
    // 处理 SQL 异常
}

try {
    operation();
} catch (IOException | SQLException e) {
    // 统一处理多种异常
}

try {
    operation();
} catch (IOException | SQLException e) {
    throw new ServiceException("Operation failed", e);
}

try {
    throw new Exception("Exception from try");
} finally {
    throw new Exception("Exception from finally"); // 覆盖了 try 的异常
}
// 最终抛出:Exception from finally

try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
    // 使用资源
} // 自动关闭

FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // 使用资源
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            // 记录日志,不要抛出异常
        }
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        System.out.println(method());
    }
    
    static int method() {
        try {
            return 1;
        } catch (Exception e) {
            return 2;
        } finally {
            return 3;
        }
    }
}

try {
    throw new Exception("Exception 1");
} catch (Exception e) {
    throw new RuntimeException("Exception 2");
} finally {
    throw new IllegalArgumentException("Exception 3");
}

try {
    // ... 一些操作
} catch (Exception e) {
    e.printStackTrace();
}

try {
    // ... 一些操作
} catch (SpecificException e) {
    logger.error("Operation failed", e);
    throw new BusinessException("User-friendly error message", e);
}

import java.util.logging.Level;
import java.util.logging.Logger;

public class Hello {
  public static void main(String[] args) {
    Logger logger = Logger.getGlobal();
    logger.info("start process...");
    logger.warning("memory is running out...");
    logger.severe("process will be terminated...");
  }
}

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Main {
  public static void main(String[] args) {
    Log log = LogFactory.getLog(Main.class);
    log.info("start...");
    log.warn("end.");
  }
}

try {
  // ...
} catch (Exception e) {
  log.error("got exception!", e);
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class Main {
  final Logger logger = LoggerFactory.getLogger(getClass());

  void test() {
    int score = 99;
    logger.info("Set score {} for Person {} ok.", score, "xiaoye");
  }
}