Java 中 throw 和 throws 的全面指南

throw new 异常类名([异常信息][, 原因异常]);

// 基本形式
throw new IllegalArgumentException("参数无效");
// 带原因异常
throw new ServiceException("处理失败", e);
// 使用预创建的异常对象
RuntimeException ex = new RuntimeException();
throw ex;

/**
 * 设置用户年龄
 * @param age 必须是非负整数
 * @throws IllegalArgumentException 当年龄为负数时抛出
 */
public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负数: " + age);
    }
    this.age = age;
}

public void withdraw(double amount) {
    if (amount <= 0) {
        throw new IllegalArgumentException("取款金额必须为正数");
    }
    if (balance < amount) {
        throw new IllegalStateException("账户余额不足");
    }
    balance -= amount;
}

public void processFile(String path) throws IOException {
    File file = new File(path);
    if (!file.exists()) {
        throw new FileNotFoundException("文件不存在: " + path);
    }
    // 文件处理逻辑...
}

public void placeOrder(Order order) {
    if (order.getItems().isEmpty()) {
        throw new EmptyOrderException("订单不能为空");
    }
    if (!inventory.checkStock(order)) {
        throw new InsufficientStockException("库存不足");
    }
    // 订单处理逻辑...
}

public class ThrowExample {
    /**
     * 验证年龄有效性
     * @param age 待验证的年龄
     * @throws IllegalArgumentException 当年龄无效时抛出
     */
    public static void validateAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数: " + age);
        }
        if (age > 150) {
            throw new IllegalArgumentException("年龄超过合理范围: " + age);
        }
        System.out.println("有效年龄: " + age);
    }
    public static void main(String[] args) {
        try {
            // 测试正常情况
            validateAge(25);
            // 测试异常情况
            validateAge(-5);
            // 这行不会执行，因为上面已经抛出异常
            validateAge(200);
        } catch (IllegalArgumentException e) {
            System.out.println("捕获到异常: " + e.getMessage());
            // 打印完整的异常堆栈
            e.printStackTrace();
        }
        System.out.println("程序继续执行...");
    }
}

[访问修饰符] [static] [final] [abstract] [synchronized] 返回值类型 方法名(参数列表) 
    throws 异常类型1, 异常类型2, ..., 异常类型N {
    // 方法实现
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class ComprehensiveThrowsExample {
    /**
     * 声明多个异常类型的示例
     * @param filePath 文件路径
     * @throws FileNotFoundException 当文件不存在时抛出
     * @throws IOException 当发生IO错误时抛出
     */
    public static void processFile(String filePath) 
            throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream(filePath);
        // 模拟IO操作
        int data = fis.read();
        while(data != -1) {
            System.out.print((char)data);
            data = fis.read();
        }
        fis.close();
    }
    /**
     * 自定义异常和运行时异常示例
     * @param dateStr 日期字符串
     * @throws ParseException 当日期格式错误时抛出
     * @throws IllegalArgumentException 当参数不合法时抛出
     */
    public static void parseDate(String dateStr) 
            throws ParseException, IllegalArgumentException {
        if(dateStr == null || dateStr.isEmpty()) {
            throw new IllegalArgumentException("日期字符串不能为空");
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        sdf.parse(dateStr);
    }
    public static void main(String[] args) {
        try {
            // 测试文件处理方法
            processFile("config.ini");
            // 测试日期解析方法
            parseDate("2023-05-15");
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到异常: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("IO异常: " + e.getMessage());
        } catch (ParseException e) {
            System.err.println("日期解析异常: " + e.getMessage());
        } catch (IllegalArgumentException e) {
            System.err.println("参数异常: " + e.getMessage());
        } finally {
            System.out.println("\n程序执行完毕");
        }
    }
}

public static int divide(int a, int b) {
    if (b == 0) {
        // 创建并抛出ArithmeticException异常实例
        throw new ArithmeticException("除数不能为0");
        // 从这里开始后续代码不会执行
    }
    return a / b;
}

public static String readFileContent(String filePath) 
    throws FileNotFoundException, IOException {
    // 实际读取文件的代码
    // 可能抛出：
    // - FileNotFoundException 当文件不存在时
    // - IOException 当读取过程中发生I/O错误时
}

throw new 异常类名(异常描述信息);

throw ArithmeticException; // 错误：缺少new关键字创建对象
throw "计算错误"; // 错误：不能直接抛出字符串
throw null; // 错误：不能抛出null

throw new ArithmeticException("除数不能为零"); // 抛出运行时异常
throw new FileNotFoundException("文件未找到: config.ini"); // 抛出检查异常
throw new IllegalArgumentException("年龄不能为负数: " + age); // 带详细错误信息

修饰符 返回值类型 方法名(参数列表) throws 异常类型1, 异常类型2, ... {
    // 方法体
}

// 声明单个异常
public void readFile() throws IOException {
    // 读取文件操作
}
// 声明多个异常
public void processData() throws SQLException, ParseException {
    // 数据库操作和日期解析
}
// 继承中的异常声明
class Parent {
    void demo() throws IOException {}
}
class Child extends Parent {
    @Override
    void demo() throws FileNotFoundException { // FileNotFoundException是IOException的子类
        // 实现代码
    }
}

// 自定义检查型异常
class MyBusinessException extends Exception {
    // 无参构造
    public MyBusinessException() {
        super("业务异常发生");
    }
    // 带详细消息的构造
    public MyBusinessException(String message) {
        super(message);
    }
    // 带原因异常的构造
    public MyBusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}
public class ExceptionDemo {
    // 方法声明可能抛出自定义异常
    public static void validate(int value) throws MyBusinessException {
        if (value < 0) {
            // 抛出自定义异常实例
            throw new MyBusinessException("数值不能为负数");
        }
        System.out.println("验证通过，值为：" + value);
    }
}

import java.io.*;
public class FileProcessor {
    // 正确：声明实际抛出的具体异常
    public static void readConfigFile(String path) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(path);
        // 其他处理...
    }
    // 正确：声明异常的父类
    public static void copyFile(String src, String dest) throws IOException {
        FileInputStream in = new FileInputStream(src);
        FileOutputStream out = new FileOutputStream(dest);
        // 文件复制操作...
    }
    // 错误示例：声明了不可能抛出的异常（编译时不会报错，但逻辑错误）
    public static void listFiles(String dir) throws SQLException {
        File folder = new File(dir);
        for (File file : folder.listFiles()) {
            System.out.println(file.getName());
        }
    }
    // 正确：声明多个异常
    public static void processFile(String path) 
        throws FileNotFoundException, SecurityException {
        // 可能抛出两种异常的操作
    }
}

class Parent {
    public void demo() throws IOException {
        // 父类实现
    }
}
class Child extends Parent {
    // 正确：可以不声明任何异常
    @Override
    public void demo() {
        // 子类实现
    }
    // 正确：可以声明相同的异常
    @Override
    public void demo() throws IOException {
        // 子类实现
    }
    // 正确：可以声明更具体的异常
    @Override
    public void demo() throws FileNotFoundException {
        // 子类实现
    }
    // 错误：不能声明更宽泛的异常
    // @Override
    // public void demo() throws Exception {
    //     // 编译错误
    // }
}

class DatabaseReader {
    public void readData() throws SQLException {
        // 读取数据库
    }
}
class MySQLReader extends DatabaseReader {
    @Override
    public void readData() throws SQLException {
        // 可以抛出相同的SQLException
    }
}
class OracleReader extends DatabaseReader {
    @Override
    public void readData() {
        // 选择不抛出任何异常
    }
}
class CustomReader extends DatabaseReader {
    @Override
    public void readData() throws BatchUpdateException {
        // 抛出SQLException的子类BatchUpdateException
    }
}

class Parent {
    // 情况1：父类声明IO异常
    public void doIO() throws IOException {
        // IO操作
    }
    // 情况2：父类不声明任何异常
    public void doNothing() {
        // 无异常操作
    }
}
class CorrectChild extends Parent {
    // 合法重写：声明完全相同的异常
    @Override
    public void doIO() throws IOException {
        // ...
    }
    // 合法重写：声明更具体的异常
    @Override
    public void doIO() throws FileNotFoundException {
        // ...
    }
    // 合法重写：不声明任何异常
    @Override
    public void doNothing() {
        // ...
    }
    // 合法重写：声明运行时异常
    @Override
    public void doNothing() throws NullPointerException {
        // ...
    }
}
class WrongChild extends Parent {
    // 非法重写：声明更宽泛的异常
    @Override
    public void doIO() throws Exception {  // 编译错误
        // ...
    }
    // 非法重写：声明新的受检异常
    @Override
    public void doNothing() throws SQLException {  // 编译错误
        // ...
    }
}

public static void checkParams(String str, int num) {
    if (str == null) {
        throw new NullPointerException("字符串不能为null");  // 第一个throw
    }
    if (num < 0) {
        throw new IllegalArgumentException("数字不能为负数");  // 第二个throw
    }
}

public static void complexOperation() 
    throws IOException, SQLException, ParseException {
    // 可能抛出多种异常的代码
    // 比如：
    // 1. 文件读写操作可能抛出IOException
    // 2. 数据库操作可能抛出SQLException
    // 3. 日期解析可能抛出ParseException
}

public String readFile(String filePath) throws FileNotFoundException {
FileReader reader = new FileReader(filePath);
// 读取文件内容的逻辑，若文件不存在，会触发FileNotFoundException
if (!new File(filePath).exists()) {
throw new FileNotFoundException("文件 " + filePath + " 不存在");
}
// 后续读取文件操作
}

public class ExceptionChain {
public static void main(String[] args) {
try {
methodA();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void methodA() throws IOException {
methodB();
}
public static void methodB() throws IOException {
methodC();
}
public static void methodC() throws IOException {
throw new FileNotFoundException("文件未找到");
}
}

class InsufficientBalanceException extends Exception {
public InsufficientBalanceException(String message) {
super(message);
}
}
public class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
this.balance = initialBalance;
}
public void withdraw(double amount) throws InsufficientBalanceException {
if (amount > balance) {
throw new InsufficientBalanceException("账户余额不足，当前余额为 " + balance + "，取款金额为 " + amount);
}
balance -= amount;
}
}

public void readData() throws IOException {
try {
// 读取数据操作，可能抛出FileNotFoundException
FileReader reader = new FileReader("data.txt");
} catch (FileNotFoundException e) {
// 捕获具体异常
throw e; // 重新抛出异常，可由调用者根据声明的IOException统一处理
}
}

// 错误写法
throw IllegalArgumentException;
// 正确写法
throw new IllegalArgumentException("参数不能为null");

public void processValue(int value) {
    if (value < 0) {
        throw new IllegalArgumentException("数值不能为负数");
        // 下面这行代码永远不会执行
        System.out.println("继续处理..."); 
    }
    // 其他处理逻辑
}

// 方式1：捕获处理
public void readFile() {
    try {
        // 可能抛出IOException的代码
    } catch (IOException e) {
        // 处理异常
    }
}
// 方式2：声明抛出
public void readFile() throws IOException {
    // 可能抛出IOException的代码
}

// 错误：声明了不相关的异常
public void process() throws SQLException {
    // 这个方法实际上不会抛出SQLException
    throw new IOException(); // 编译错误
}
// 正确
public void process() throws IOException {
    throw new IOException();
}

// 情况1：捕获处理
public void caller() {
    try {
        methodThrowsException();
    } catch (IOException e) {
        // 处理异常
    }
}
// 情况2：继续声明
public void caller() throws IOException {
    methodThrowsException();
}

class Parent {
    public void demo() throws IOException {
        // 父类方法
    }
}
class Child extends Parent {
    // 正确：不抛出异常
    @Override
    public void demo() {
        // 子类实现
    }
    // 正确：抛出更具体的异常
    @Override
    public void demo() throws FileNotFoundException {
        // 子类实现
    }
    // 错误：抛出更宽泛的异常
    @Override
    public void demo() throws Exception {
        // 编译错误
    }
}