【Java SE】深入理解异常处理机制

重生之我是Java开发战士

557人浏览 · 2025-08-26 22:03:43

重生之我是Java开发战士 · 2025-08-26 22:03:43 发布

文章目录

一、异常的概念与体系结构
二、异常的处理方式
三、自定义异常类
四、异常处理的最佳实践

一、异常的概念与体系结构

1.1 什么是异常

异常是指在程序执行过程中发生的不正常行为或事件，它会中断正常的指令流。例如：

算术异常

System.out.println(10 / 0);
//执行结果：Exception in thread "main" java.lang.ArithmeticException: / by zero

数组越界异常

int[] arr = {1, 2, 3};
System.out.println(arr[100]);
// 执行结果：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

空指针异常

int[] arr = null;
System.out.println(arr.length);
// 执行结果：Exception in thread "main" java.lang.NullPointerException

Java为不同类型的异常提供了相应的类来进行描述和处理，这种面向对象的异常处理机制是Java语言的一大特色。

1.2 异常的体系结构

Java为了对不同异常和错误进行分类管理，维护了一个层次化的异常体系结构：

在这里插入图片描述

Throwable类

Throwable类是Java异常体系的顶层类，是所有异常和错误的超类。它提供了异常链、堆栈跟踪等信息，派生出两个重要的子类：Error和Exception。

Error类

Error指的是Java虚拟机无法解决的严重问题，通常与程序员的代码无关，而是系统级别的问题。例如：

StackOverflowError：栈溢出错误，通常由无限递归引起
OutOfMemoryError：内存溢出错误，当JVM没有足够内存分配对象时抛出

Error通常是不可恢复的，一旦发生，程序往往无力回天，只能终止运行。

Exception类

Exception是程序本身可以处理的异常，是程序员关注的重点。Exception又分为两大类：受检异常（checked exceptions）和非受检异常（unchecked exceptions）。

1.3 异常的分类

根据异常发生的时机和处理要求，Java异常可分为：

编译时异常（受检异常）

在程序编译期间发生的异常称为编译时异常，也称为受检异常（Checked Exception）。这些异常必须被处理，否则代码无法通过编译。

public class Person {
    private String name;
    private String gender;
    int age;
    
    @Override
    public Person clone() {
        return (Person)super.clone(); // 编译错误：未处理CloneNotSupportedException
    }
}

常见的受检异常包括：IOException、SQLException、ClassNotFoundException等。

运行时异常（非受检异常）

在程序执行期间发生的异常称为运行时异常，也称为非受检异常（Unchecked Exception）。这些异常通常是编程错误导致的，不强制要求处理。

// 空指针异常
String str = null;
System.out.println(str.length());

// 数组越界异常
int[] arr = new int[5];
System.out.println(arr[5]);

// 算术异常
int result = 10 / 0;

RuntimeException及其子类都是运行时异常，如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException等。

注意：编译时出现的语法错误不属于异常范畴。例如将System.out.println拼写错误为system.out.println，这是在编译期就能发现的错误，而不是运行时异常。

二、异常的处理方式

2.1 防御式编程哲学

错误在代码中是客观存在的，因此我们需要让程序在出现问题时能够及时通知程序员。主要有两种防御式编程风格：

LBYL: Look Before You Leap（事前防御型）

在操作之前做充分的检查，防止错误发生。

boolean ret = false;
ret = 登陆游戏();
if (!ret) {
    处理登陆游戏错误;
    return;
}
ret = 开始匹配();
if (!ret) {
    处理匹配错误;
    return;
}
ret = 游戏确认();
if (!ret) {
    处理游戏确认错误;
    return;
}
// ...更多检查

缺陷：正常流程和错误处理流程代码混在一起，代码整体显得混乱，可读性差。

EAFP: It’s Easier to Ask Forgiveness than Permission（事后认错型）

先操作，遇到问题再处理。这是Java异常处理的核心思想。

try {
    登陆游戏();
    开始匹配();
    游戏确认();
    选择英雄();
    载入游戏画面();
    // ...更多操作
} catch (登陆游戏异常) {
    处理登陆游戏异常;
} catch (开始匹配异常) {
    处理开始匹配异常;
} catch (游戏确认异常) {
    处理游戏确认异常;
} catch (选择英雄异常) {
    处理选择英雄异常;
} catch (载入游戏画面异常) {
    处理载入游戏画面异常;
}

优势：正常流程和错误流程分离，程序员更关注正常流程，代码更清晰易理解。

Java异常处理基于EAFP思想，主要使用五个关键字：throw、try、catch、finally、throws。

2.2 异常的抛出（throw）

在编写程序时，如果出现错误，需要将错误信息告知调用者。Java中使用throw关键字抛出一个指定的异常对象。

// 实现一个获取数组中任意位置元素的方法
public static int getElement(int[] array, int index) {
    if (null == array) {
        throw new NullPointerException("传递的数组为null");
    }
    
    if (index < 0 || index >= array.length) {
        throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
    }
    
    return array[index];
}

public static void main(String[] args) {
    int[] array = {1, 2, 3};
    getElement(array, 3); // 抛出ArrayIndexOutOfBoundsException
}

throw使用注意事项：

throw必须写在方法体内部
抛出的对象必须是Exception或其子类对象
如果抛出的是RuntimeException或其子类，则可以不用处理，直接交给JVM处理
如果抛出的是编译时异常，则必须处理，否则无法通过编译
异常一旦抛出，其后的代码就不会执行

2.3 异常的捕获

异常的捕获有两种主要方式：异常声明throws和try-catch捕获处理。

2.3.1 异常声明throws

在方法声明时使用 throws 关键字，将异常抛给方法的调用者处理。

public class Config {
    File file;
    
    /**
     * FileNotFoundException是编译时异常，此处不处理也没有能力处理，
     * 应该将错误信息报告给调用者
     */
    public void openConfig(String filename) throws FileNotFoundException {
        if (!filename.equals("config.ini")) {
            throw new FileNotFoundException("配置文件名字不对");
        }
        // 打开文件
    }
    
    public void readConfig() {
        // 读取配置
    }
}

throws使用注意事项：

throws必须跟在方法的参数列表之后
声明的异常必须是Exception或其子类
方法内部如果抛出多个异常，throws之后必须跟多个异常类型，用逗号隔开
如果抛出多个异常类型具有父子关系，直接声明父类即可
调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

调用声明异常的方法

public static void main(String[] args) throws IOException {
    Config config = new Config();
    config.openConfig("config.ini");
}

或者使用try-catch处理

public static void main(String[] args) {
    Config config = new Config();
    try {
        config.openConfig("config.ini");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

现代IDE（如IntelliJ IDEA）通常提供快速处理异常的功能，如使用Alt+Insert快捷键选择"Add exception to method signature"或"Surround with try/catch"。

2.3.2 try-catch捕获并处理

throws对异常并没有真正处理，而是将异常报告给调用者。 如果真正要对异常进行处理，就需要使用try-catch。

try {
    // 将可能出现异常的代码放在这里
} catch (异常类型1 e) {
    // 处理异常类型1
} catch (异常类型2 e) {
    // 处理异常类型2
} finally {
    // 此处代码一定会被执行到
}
// 后续代码

示例：读取配置文件并处理异常

public class Config {
    File file;
    
    public void openConfig(String filename) throws FileNotFoundException {
        if (!filename.equals("config.ini")) {
            throw new FileNotFoundException("配置文件名字不对");
        }
        // 打开文件
    }
    
    public static void main(String[] args) {
        Config config = new Config();
        try {
            config.openConfig("config.txt");
            System.out.println("文件打开成功");
        } catch (FileNotFoundException e) {
            // 异常的处理方式
            System.out.println(e.getMessage()); // 只打印异常信息
            System.out.println(e); // 打印异常类型：异常信息
            e.printStackTrace(); // 打印信息最全面
        }
        
        // 一旦异常被捕获处理了，此处的代码会执行
        System.out.println("异常如果被处理了，这里的代码也可以执行");
    }
}

异常处理方式的选择：

在实际开发中，我们需要根据不同的业务场景决定如何处理异常：

对于严重问题（如算法相关场景）：应该让程序直接崩溃，防止造成更严重的后果
对于不太严重的问题（大多数场景）：记录错误日志，并通过监控报警程序及时通知程序员
对于可能恢复的问题（如网络相关场景）：可以尝试进行重试

try-catch注意事项：

try块内抛出异常位置之后的代码将不会被执行
如果抛出异常类型与catch时异常类型不匹配，异常不会被成功捕获，会继续往外抛
try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    
    try {
        System.out.println("before");
        // arr = null;
        System.out.println(arr[100]);
        System.out.println("after");
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("这是个数组下标越界异常");
        e.printStackTrace();
    } catch (NullPointerException e) {
        System.out.println("这是个空指针异常");
        e.printStackTrace();
    }
    System.out.println("after try catch");
}

如果多个异常的处理方式完全相同，可以使用多重捕获

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
    // 处理这两种异常
    e.printStackTrace();
}

如果异常之间具有父子关系，子类异常必须在前catch，父类异常在后catch。否则所有异常都会被父类捕获

try {
    // 可能抛出异常的代码
} catch (NullPointerException e) {
    // 处理空指针异常
} catch (Exception e) {
    // 处理其他异常
}

可以通过一个catch捕获所有异常（不推荐）

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 捕获所有异常
    e.printStackTrace();
}

由于Exception类是所有异常类的父类，因此可以捕获所有异常。但这样做会丢失异常的具体类型信息，不利于精确处理。

2.3.3 finally块

在程序中，有些特定的代码不论是否发生异常都需要执行，比如资源回收操作（关闭网络连接、数据库连接、IO流等）。finally块就是用来解决这个问题的。

try {
    // 可能会发生异常的代码
} catch (异常类型 e) {
    // 对捕获到的异常进行处理
} finally {
    // 此处的语句无论是否发生异常，都会被执行到
}

示例：

public static void main(String[] args) {
    try {
        int[] arr = {1, 2, 3};
        arr[100] = 10; // 抛出异常
        arr[0] = 10;   // 这行不会执行
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println(e);
    } finally {
        System.out.println("finally中的代码一定会执行");
    }
    System.out.println("如果没有抛出异常，或者异常被处理了，try-catch后的代码也会执行");
}

finally的重要性：

既然finally和try-catch后的代码都会执行，那为什么还要有finally呢？看下面的例子：

public class TestFinally {
    public static int getData() {
        Scanner sc = null;
        try {
            sc = new Scanner(System.in);
            int data = sc.nextInt();
            return data; // 这里返回后，后面的代码不会执行
        } catch (InputMismatchException e) {
            e.printStackTrace();
        } finally {
            System.out.println("finally中代码");
            if (null != sc) {
                sc.close(); // 确保资源被释放
            }
        }
        System.out.println("try-catch-finally之后代码");
        return 0;
    }
    
    public static void main(String[] args) {
        int data = getData();
        System.out.println(data);
    }
}

如果没有finally块，当正常输入时，return语句执行后，后面的代码（包括资源释放代码）根本不会执行，导致资源泄漏。

finally执行时机：

finally执行的时机是在方法返回之前（try或catch中的return会在这个return之前执行finally）。但如果finally中也存在return语句，那么就会执行finally中的return。

public static void main(String[] args) {
    System.out.println(func()); // 输出20而不是10
}

public static int func() {
    try {
        return 10;
    } finally {
        return 20; // 这会覆盖try中的return
    }
}

注意：一般不建议在finally中写return语句，这会被编译器当作警告，因为它会掩盖try和catch块中的异常或返回值。

面试题解答：

throw和throws的区别？
- throw用于在方法体内抛出异常对象，throws用于方法声明处抛出异常类型
- throw只能抛出一个异常对象，throws可以抛出多个异常类型
- throw表示一定抛出了异常，throws表示可能抛出异常
finally中的语句一定会执行吗？
- 正常情况下，finally中的语句一定会执行
- 但在某些极端情况下不会执行，如：
  - JVM提前退出（System.exit()）
  - 线程被中断或杀死
  - finally块中发生未处理的异常
  - 系统崩溃或断电等硬件问题

2.4 异常的处理流程

调用栈概念

方法之间存在相互调用关系，这种关系可以用"调用栈"来描述。JVM中有一块内存空间称为"虚拟机栈"，专门存储方法之间的调用关系。当代码中出现异常时，可以使用e.printStackTrace()查看出现异常代码的调用栈。

如果当前方法没有合适的处理异常的方式，就会沿着调用栈向上传递：

public static void main(String[] args) {
    try {
        func();
    } catch (ArrayIndexOutOfBoundsException e) {
        e.printStackTrace();
    }
    System.out.println("after try catch");
}

public static void func() {
    int[] arr = {1, 2, 3};
    System.out.println(arr[100]); // 抛出异常
}

// 输出结果：
// java.lang.ArrayIndexOutOfBoundsException: 100
//     at Test.func(Test.java:18)
//     at Test.main(Test.java:9)
// after try catch

如果向上一直传递都没有合适的方法处理异常，最终就会交给JVM处理，程序就会异常终止：

public static void main(String[] args) {
    func(); // 没有try-catch处理异常
    System.out.println("after try catch"); // 这行不会执行
}

public static void func() {
    int[] arr = {1, 2, 3};
    System.out.println(arr[100]); // 抛出异常
}

// 输出结果：
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
//     at Test.func(Test.java:14)
//     at Test.main(Test.java:8)

异常处理流程总结

程序先执行try中的代码
如果try中的代码出现异常，就会结束try中的代码，检查catch中的异常类型是否匹配
如果找到匹配的异常类型，就会执行catch中的代码
如果没有找到匹配的异常类型，就会将异常向上传递到上层调用者
无论是否找到匹配的异常类型，finally中的代码都会被执行到（在该方法结束之前执行）
如果上层调用者也没有处理异常，就继续向上传递
一直到main方法也没有合适的代码处理异常，就会交给JVM处理，此时程序就会异常终止

三、自定义异常类

虽然Java已经内置了丰富的异常类，但并不能完全表示实际开发中遇到的所有异常情况。此时就需要创建符合我们实际情况的自定义异常类。

3.1 自定义异常的场景

例如，我们实现一个用户登录功能：

public class Login {
    private String userName = "admin";
    private String password = "123456";
    //getter and setter
    
    public void loginInfo(String userName, String password) {
        if (!this.userName.equals("admin")) {
            // 需要抛出用户名错误异常
        }
        if (!this.password.equals("123456")) {
            // 需要抛出密码错误异常
        }
        System.out.println("登陆成功");
    }
    
    public static void main(String[] args) {
        Login login = new Login()
        //setter
        login.loginInfo("admin", "123456");
    }
}

在处理用户名密码错误时，我们需要抛出两种不同的异常，这时就可以创建自定义异常类。

3.2 自定义异常的实现

自定义异常类通常需要继承Exception或RuntimeException，并实现一个带有String类型参数的构造方法：

// 用户名异常
class UserNameException extends Exception {
    public UserNameException(String message) {
        super(message);
    }
}

// 密码异常
class PasswordException extends Exception {
    public PasswordException(String message) {
        super(message);
    }
}

然后修改登录代码：

public class Login {
    private static final String VALID_USERNAME = "admin";
    private static final String VALID_PASSWORD = "123456";
    
    public static void loginInfo(String userName, String password) 
            throws UserNameException, PasswordException {
        if (!VALID_USERNAME.equals(userName)) {
            throw new UserNameException("用户名错误！");
        }
        if (!VALID_PASSWORD.equals(password)) {
            throw new PasswordException("密码错误！");
        }
        System.out.println("登陆成功");
    }
    
    public static void main(String[] args) {
        try {
            loginInfo("admin", "wrongpassword");
        } catch (UserNameException e) {
            e.printStackTrace();
        } catch (PasswordException e) {
            e.printStackTrace();
        }
    }
}

3.3 自定义异常的注意事项

自定义异常通常会继承自Exception或RuntimeException
继承自Exception的异常默认是受检异常（必须处理）
继承自RuntimeException的异常默认是非受检异常（可选择处理）
建议提供多个构造方法，以便于不同的使用场景
自定义异常应该包含有意义的异常信息，便于排查问题

更完善的自定义异常示例：

// 自定义业务异常基类
public class BusinessException extends RuntimeException {
    private String errorCode;
    
    public BusinessException(String message) {
        super(message);
    }
    
    public BusinessException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }
    
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public BusinessException(String errorCode, String message, Throwable cause) {
        super(message, cause);
        this.errorCode = errorCode;
    }
    
    public String getErrorCode() {
        return errorCode;
    }
}

// 用户名异常
class UserNameException extends BusinessException {
    public UserNameException(String message) {
        super("USER_NAME_ERROR", message);
    }
}

// 密码异常
class PasswordException extends BusinessException {
    public PasswordException(String message) {
        super("PASSWORD_ERROR", message);
    }
    
    public PasswordException(String message, Throwable cause) {
        super("PASSWORD_ERROR", message, cause);
    }
}

四、异常处理的最佳实践

在实际开发中，正确处理异常至关重要。以下是一些异常处理的最佳实践：

4.1 不要忽略异常

空的catch块是异常处理中最常见的错误之一：

错误做法：忽略异常

try {
    // 可能出错的代码
} catch (Exception e) {
    // 什么都不做
}

正确做法：至少记录异常

try {
    // 可能出错的代码
} catch (Exception e) {
    log.error("发生异常", e); // 使用日志记录异常
}

4.2 选择恰当的异常类型

抛出异常时，应该选择最适合的异常类型：

不推荐：使用过于通用的异常

throw new Exception("文件未找到");

推荐：使用具体的异常类型

throw new FileNotFoundException("配置文件config.ini未找到");

4.3 提供有意义的异常信息

异常信息应该清晰明确，包含足够的信息帮助定位问题：

不推荐：异常信息过于简单

throw new IllegalArgumentException("参数错误");

推荐：提供详细的异常信息

throw new IllegalArgumentException("参数userId不能为空，当前值：null");

4.4 异常链的使用

当捕获一个异常后抛出另一个异常时，应该保留原始异常信息：

try {
    // 可能抛出IOException的代码
} catch (IOException e) {
    // 保留原始异常信息
    throw new BusinessException("业务处理失败", e);
}

4.5 性能考虑

异常处理不应该影响正常代码的性能，特别是在频繁执行的代码路径中：

不推荐：在循环中使用异常处理流程控制

for (int i = 0; i < array.length; i++) {
    try {
        if (array[i] < 0) {
            throw new InvalidValueException("值不能为负");
        }
        // 处理正常值
    } catch (InvalidValueException e) {
        // 处理异常值
    }
}

推荐：使用条件判断代替异常

for (int i = 0; i < array.length; i++) {
    if (array[i] < 0) {
        // 处理异常值
    } else {
        // 处理正常值
    }
}

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

2026年AI Agent框架横评：OpenClaw vs LangGraph vs CrewAI vs Superpowers，选型指南

AI Agent技术社区

Caveman实测 – AI Agent 的极简输出压缩插件

AI Agent技术社区

Agent 开发主流 Skills 推荐

本文梳理了AI Agent开发中的关键Skill模块及其选型建议。主要涵盖六类核心技能：1）信息检索类（Web搜索、文档检索等）；2）代码工具类（Python执行、API调用等）；3）多模态处理类（图像分析、OCR等）；4）记忆管理类（对话记忆、状态机等）；5）协作通信类（多Agent交互、消息集成）；6）工作流编排类。选型应遵循场景适配、生态成熟度、安全隔离和可组合性原则，推荐优先选择LangC

AI Agent技术社区

所有评论(0)

查看更多评论

重生之我是Java开发战士

@2501_90752941

已为社区贡献9条内容

【Java SE】深入理解异常处理机制

重生之我是Java开发战士

文章目录

一、异常的概念与体系结构

1.1 什么是异常

1.2 异常的体系结构

Throwable类

Error类

Exception类

1.3 异常的分类

编译时异常（受检异常）

运行时异常（非受检异常）

二、 异常的处理方式

2.1 防御式编程哲学

LBYL: Look Before You Leap（事前防御型）

EAFP: It’s Easier to Ask Forgiveness than Permission（事后认错型）

2.2 异常的抛出（throw）

2.3 异常的捕获

2.3.1 异常声明throws

2.3.2 try-catch捕获并处理

2.3.3 finally块

2.4 异常的处理流程

调用栈概念

异常处理流程总结

三、 自定义异常类

3.1 自定义异常的场景

3.2 自定义异常的实现

3.3 自定义异常的注意事项

四、 异常处理的最佳实践

4.1 不要忽略异常

4.2 选择恰当的异常类型

4.3 提供有意义的异常信息

4.4 异常链的使用

4.5 性能考虑

所有评论(0)

温馨提示：您尚未绑定手机号

重生之我是Java开发战士

二、异常的处理方式

三、自定义异常类

四、异常处理的最佳实践