Java基础面试专栏（三十一）：throw和throws关键字的区别

PeterMap
3 阅读11分钟

在Java异常处理中，throw和throws是两个高频出现、极易混淆的关键字。很多开发者在编码时误用两者，导致编译报错或异常处理逻辑失效；面试中，两者的区别也是基础必考题，若无法清晰区分，很容易错失高分。

本文将完全贴合面试答题逻辑，按“核心定位+区别对比+详细讲解+代码示例+常见错误”的结构，拆解两者的核心差异，仅围绕核心内容展开，帮大家吃透底层逻辑、避开常见误区，掌握标准答题模板，轻松应对面试提问和实际编码。

面试万能开场白（直接套用，快速定调）：面试官您好，throw和throws关键字的核心区别的是“动作与声明”的差异——throw是主动抛出具体异常对象的动作，用于方法内部；throws是声明方法可能抛出异常类型的声明，用于方法签名处，二者配合实现Java异常处理的责任转移。

一、核心定位（一句话快速区分）

无需复杂拆解，记住这两句话，就能快速区分两者的核心作用，面试时可直接作为开篇回答：

  • throw：是「动作」，用于方法体内部，主动创建并抛出一个具体的异常对象，触发异常流程；

  • throws：是「声明」，用于方法签名处，告知调用者当前方法可能会抛出的异常类型，提醒调用者进行处理。

二、核心区别对比（表格清晰，面试必记）

通过表格对比两者的关键维度，直观区分差异，面试时若能准确说出3-4个核心维度，就能体现对知识点的掌握程度：

对比维度throw关键字throws关键字
书写位置方法体内部（可在if分支、循环等逻辑中）方法签名处（参数列表之后，方法体之前）
核心作用主动抛出具体的异常对象，终止当前方法执行声明方法可能抛出的异常类型，提醒调用者处理
语法形式throw new 异常类(异常提示信息);方法名(参数列表) throws 异常类型1, 异常类型2 { ... }
操作内容操作的是「异常对象」（必须是Throwable的子类）操作的是「异常类型」（可声明多个，用逗号分隔）
编译约束抛出编译时异常，需配合throws声明或内部try-catch；运行时异常无强制约束声明编译时异常后，调用者必须处理（try-catch或继续throws）；运行时异常声明可省略
数量限制一个throw语句只能抛出一个异常对象可声明多个异常类型，用逗号分隔

三、详细讲解 + 代码示例（可直接运行，面试手写加分）

结合具体代码示例，拆解两者的使用场景和核心规则，理解“动作”与“声明”的本质差异，避免编码误用。

1. throw关键字：主动抛出具体异常（方法内部的动作）

核心规则：throw用于方法体内部，当满足特定条件时，主动创建异常对象并抛出，抛出后当前方法会立即终止，后续代码不再执行。根据抛出的异常类型，分为两种使用场景。

场景1：抛出运行时异常（无需配合throws）

运行时异常（如IllegalArgumentException、NullPointerException）属于非检查异常，抛出时无需在方法签名处声明，编译器不会强制约束，但运行时会触发异常。

// 模拟用户登录，校验用户名合法性
public class ThrowRuntimeDemo {
    // 校验用户名：不能为null或空字符串
    public static void checkUsername(String username) {
        // 满足异常条件，主动抛出运行时异常
        if (username == null || username.trim().isEmpty()) {
            throw new IllegalArgumentException("用户名不能为空或空白字符");
        }
        // 异常抛出后，以下代码不会执行
        System.out.println("用户名校验通过：" + username);
    }

    public static void main(String[] args) {
        // 调用方法，触发异常（可选择try-catch处理，也可不用）
        try {
            checkUsername(""); // 传入空字符串，触发异常
        } catch (IllegalArgumentException e) {
            // 捕获异常并处理
            System.out.println("异常处理：" + e.getMessage());
        }
    }
}

运行结果：异常处理：用户名不能为空或空白字符

关键说明：throw抛出运行时异常后，方法无需用throws声明，调用者可根据需求选择是否处理（不处理会导致程序终止）。

场景2：抛出编译时异常（必须配合throws或try-catch）

编译时异常（如ClassNotFoundException、ParseException）属于检查异常，抛出时必须进行处理——要么在方法内部用try-catch捕获，要么在方法签名处用throws声明，否则编译器会直接报错。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

// 模拟日期解析，抛出编译时异常
public class ThrowCheckedDemo {
    // 解析日期字符串，抛出ParseException（编译时异常），方法需用throws声明
    public static Date parseDate(String dateStr) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 日期格式不匹配时，主动抛出ParseException
        if (!dateStr.matches("\d{4}-\d{2}-\d{2}")) {
            throw new ParseException("日期格式不正确，需符合yyyy-MM-dd", 0);
        }
        return sdf.parse(dateStr);
    }

    public static void main(String[] args) {
        // 调用声明了编译时异常的方法，必须处理（try-catch或继续throws）
        try {
            parseDate("2026/04/19"); // 格式错误，触发异常
        } catch (ParseException e) {
            System.out.println("异常处理：" + e.getMessage());
        }
    }
}

运行结果：异常处理：日期格式不正确，需符合yyyy-MM-dd

关键说明：throw抛出编译时异常后，若不在方法内部捕获，必须在方法签名处用throws声明，否则编译失败。

2. throws关键字：声明方法可能抛出的异常（方法签名的声明）

核心规则：throws用于方法签名处，作用是“告知调用者”当前方法可能会抛出哪些异常，将异常处理的责任转移给调用者。它仅做“声明”，不代表方法一定会抛出异常，也不触发异常流程。

场景1：声明多个编译时异常

当方法可能抛出多种编译时异常时，可在throws后用逗号分隔多个异常类型，调用者需处理所有声明的异常（或继续throws）。

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

// 模拟读取文件，声明多个编译时异常
public class ThrowsMultiDemo {
    // 声明可能抛出FileNotFoundException和IOException
    public static void readFile(String filePath) throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream(filePath);
        // 读取文件内容（简化逻辑）
        int data = fis.read();
        while (data != -1) {
            System.out.print((char) data);
            data = fis.read();
        }
        fis.close();
    }

    public static void main(String[] args) {
        // 调用者处理多个异常（try-catch捕获，或继续throws）
        try {
            readFile("test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("异常处理：文件未找到：" + e.getMessage());
        } catch (IOException e) {
            System.out.println("异常处理：文件读取失败：" + e.getMessage());
        }
    }
}

关键说明：方法声明多个异常后，调用者需逐一处理，或在main方法后继续用throws声明，将责任转移给JVM（JVM会终止程序并打印异常信息）。

场景2：声明运行时异常（可选）

运行时异常可不用throws声明，但为了提醒调用者注意该方法可能出现的异常，也可主动声明，此时调用者可不用处理（但运行时会触发异常）。

// 模拟除法运算，声明运行时异常（提醒调用者）
public class ThrowsRuntimeDemo {
    // 声明可能抛出ArithmeticException（运行时异常，可选）
    public static int divide(int num1, int num2) throws ArithmeticException {
        // 除数为0时，主动抛出异常
        if (num2 == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        return num1 / num2;
    }

    public static void main(String[] args) {
        // 调用声明了运行时异常的方法，可不用try-catch（运行时会抛异常）
        // divide(10, 0); // 取消注释，运行时会抛出ArithmeticException
        divide(10, 2); // 正常执行，输出5
    }
}

关键说明：throws声明运行时异常仅起“提醒作用”，不强制调用者处理，与不声明的效果一致。

四、常见错误示例（避开编码坑，面试加分）

结合实际编码中的高频错误，拆解错误原因和正确写法，帮大家避免类似问题，面试中若能说出常见错误，会更显专业。

错误1：抛出编译时异常但不声明throws，也不捕获

// 错误示例：抛编译时异常，未声明throws也未捕获，编译报错
public static void errorDemo1() {
    // 错误：ParseException是编译时异常，需处理（throws或try-catch）
    throw new ParseException("日期解析错误", 0);
}

报错原因：编译时异常必须被处理，要么在方法内部用try-catch捕获，要么在方法签名处用throws声明。

正确写法：

// 正确写法1：用throws声明
public static void correctDemo1() throws ParseException {
    throw new ParseException("日期解析错误", 0);
}

// 正确写法2：用try-catch捕获
public static void correctDemo2() {
    try {
        throw new ParseException("日期解析错误", 0);
    } catch (ParseException e) {
        e.printStackTrace();
    }
}

错误2：throw后跟异常类型，而非异常对象

// 错误示例：throw后必须是异常对象，不能是异常类型
public static void errorDemo2() {
    // 错误：ParseException是类型，需创建对象（new ParseException(...)）
    throw ParseException;
}

正确写法：throw new ParseException("日期解析错误", 0);

错误3：throws声明异常后，方法内未抛出对应异常（语法合法，逻辑冗余）

// 冗余示例：throws声明了异常，但方法内未抛出，语法合法但无意义
public static void errorDemo3() throws ParseException {
    System.out.println("方法内未抛出任何异常");
}

说明：这种写法语法上合法，但throws的声明毫无意义，还会误导调用者进行不必要的异常处理，编码时需避免。

五、throw + throws 配合使用的典型场景（实际开发常用）

实际开发中，两者常配合使用：方法内用throw抛出具体的异常对象，触发异常流程；方法签名用throws声明异常类型，将异常处理的责任转移给调用者，实现异常的分层处理。

import java.sql.SQLException;

// 模拟用户注册，配合使用throw和throws
public class ThrowAndThrowsDemo {
    // 声明可能抛出SQLException（编译时异常）
    public static void registerUser(String username, String password) throws SQLException {
        // 校验用户名和密码合法性，不满足则抛异常
        if (username == null || password == null) {
            throw new SQLException("用户名或密码不能为空");
        }
        if (password.length() < 6) {
            throw new SQLException("密码长度不能小于6位");
        }
        // 模拟数据库注册操作
        System.out.println("用户注册成功：" + username);
    }

    public static void main(String[] args) {
        // 调用者处理异常，实现分层处理
        try {
            registerUser("testUser", "12345"); // 密码长度不足，触发异常
        } catch (SQLException e) {
            System.out.println("注册失败：" + e.getMessage());
        }
    }
}

运行结果：注册失败：密码长度不能小于6位

关键说明：这种配合方式既明确了方法可能出现的异常类型，又实现了异常的具体触发，是实际开发中异常处理的常用方式。

六、面试答题模板（直接背诵，稳拿高分）

面试时按以下逻辑答题，条理清晰、重点突出，避免遗漏核心考点：

  1. 定调：throw和throws的核心区别是“动作与声明”的差异，throw是主动抛出具体异常对象的动作，throws是声明方法可能抛出异常类型的声明；

  2. 分点阐述核心区别（结合2-3个关键维度）：

  • 位置不同：throw在方法体内部，throws在方法签名处；

  • 作用不同：throw主动触发异常、终止方法，throws仅声明异常、转移处理责任；

  • 操作内容不同：throw操作异常对象，throws操作异常类型；

  1. 补充配合使用场景：方法内用throw抛具体异常，方法签名用throws声明，将异常处理责任转移给调用者；

  2. 易错点提醒：throw后必须是异常对象，编译时异常抛出需配合throws或try-catch。

七、面试加分金句（记住即可，瞬间拔高档次）

  1. throw是“做动作”，触发异常；throws是“做声明”，提醒处理，二者相辅相成，完成异常的触发与责任转移；

  2. throws仅声明“可能抛异常”，不代表方法一定会抛；throw一定会触发异常，且抛出后当前方法立即终止；

  3. 编译时异常必须被处理（throw后需配合throws或try-catch），运行时异常无强制约束，仅需根据需求处理。

总结

throw和throws关键字的核心区别，本质是“动作与声明”的差异：throw负责“主动抛出具体异常”，是异常的触发者；throws负责“声明可能抛出的异常类型”，是异常责任的转移者。掌握两者的位置、作用和使用规则，既能避免编码中的编译错误，也能在面试中清晰应答，轻松应对相关提问。

avatar
文章
阅读
粉丝