Android面试-Java 异常体系详解:从 Throwable 到自定义异常

0 阅读7分钟

​

 一、为什么需要异常体系

在 Java 中,程序运行过程中难免会遇到各种意外情况:文件不存在、网络中断、数组越界、除数为零、类型转换失败等。Java 通过一套完整的异常体系来统一描述、传递和处理这些运行时问题,让开发者能够把「正常业务逻辑」和「错误处理逻辑」分离开来,从而写出更健壮、更易维护的代码。

理解异常体系,核心要回答三个问题:异常从哪里来(继承结构)、异常怎么分类(受检与非受检)、异常怎么处理(捕获、抛出与传播)。

二、异常体系的整体结构

Java 中所有异常和错误的根类型都是 java.lang.Throwable。它下面分为两大分支:Error 和 Exception。

flowchart TD
    A[Throwable] --> B[Error]
    A --> C[Exception]
    B --> B1[VirtualMachineError]
    B --> B2[OutOfMemoryError]
    B --> B3[StackOverflowError]
    B --> B4[NoClassDefFoundError]
    C --> D[RuntimeException 非受检异常]
    C --> E[受检异常 Checked Exception]
    D --> D1[NullPointerException]
    D --> D2[ArrayIndexOutOfBoundsException]
    D --> D3[ClassCastException]
    D --> D4[ArithmeticException]
    D --> D5[IllegalArgumentException]
    E --> E1[IOException]
    E --> E2[SQLException]
    E --> E3[ClassNotFoundException]
    E --> E4[InterruptedException]

从图中可以看出,Throwable 是唯一的顶层父类,Error 与 Exception 是两条完全不同的处理路线。

三、Throwable 的核心方法

Throwable 定义了异常对象的基本能力,最常用的方法如下:

方法说明
getMessage()返回异常的详细描述信息
getCause()返回导致该异常的原因异常(异常链)
printStackTrace()把异常堆栈打印到标准错误流,便于定位问题
getStackTrace()返回堆栈跟踪元素数组,可用于程序化分析
toString()返回异常类名和详细信息

其中异常链(cause)非常重要:当我们在捕获一个异常后抛出另一个异常时,应把原异常作为 cause 传入,避免原始错误信息丢失。

四、Error:程序无法处理的严重问题

Error 表示 JVM 层面的严重错误,通常与代码逻辑无关,而是运行环境或资源出现了不可恢复的问题,例如:

  • OutOfMemoryError:堆内存耗尽。
  • StackOverflowError:递归过深导致栈溢出。
  • NoClassDefFoundError:类在编译时存在、运行时却找不到。

对于 Error,应用程序一般不应该捕获,也无法有效恢复。正确的做法是排查根本原因(如调整内存参数、修复递归逻辑),而不是用 catch 掩盖问题。

五、Exception:程序可以处理的异常

Exception 是应用开发中最常打交道的分支,它又分为受检异常和非受检异常两类,这是 Java 异常体系中最容易被混淆、也最需要掌握的部分。

5.1 受检异常(Checked Exception)

受检异常继承自 Exception 但不继承 RuntimeException。编译器会强制要求开发者处理它:要么用 try-catch 捕获,要么在方法签名上用 throws 声明抛出,否则编译不通过。

常见例子包括 IOException、SQLException、ClassNotFoundException、InterruptedException。这类异常通常表示「外部环境导致、但程序有可能恢复」的问题,例如文件读取失败后可以提示用户重试。

5.2 非受检异常(Unchecked Exception)

非受检异常即 RuntimeException 及其子类。编译器不强制处理,通常代表程序逻辑错误,例如:

  • NullPointerException:对 null 对象调用方法。
  • ArrayIndexOutOfBoundsException:数组下标越界。
  • ClassCastException:类型转换不合法。
  • ArithmeticException:如整数除以零。
  • IllegalArgumentException:传入参数不合法。

这类异常的正确处理方式是修复代码逻辑,而不是到处 catch 后忽略。

5.3 两类异常的对比

对比项受检异常非受检异常
继承关系Exception 的子类(非 RuntimeException)RuntimeException 及其子类
编译期检查强制处理不强制处理
典型代表IOException、SQLExceptionNullPointerException、IllegalArgumentException
语义外部可恢复问题程序逻辑缺陷
处理建议捕获并给出恢复策略,或向上抛出修复代码,避免发生

六、异常处理的语法

6.1 try-catch-finally

try 块中放置可能出错的代码,catch 捕获并处理,finally 无论是否发生异常都会执行,常用于释放资源。

public class TryCatchDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("算术异常:" + e.getMessage());
        } finally {
            System.out.println("finally 块始终执行");
        }
    }
}

6.2 多重 catch 与异常顺序

一个 try 可以对应多个 catch,但必须遵循从子类到父类的顺序,否则子类分支永远无法命中,编译会报错。

try {
    String s = null;
    System.out.println(s.length());
} catch (NullPointerException e) {
    System.out.println("空指针异常");
} catch (RuntimeException e) {
    System.out.println("运行时异常");
} catch (Exception e) {
    System.out.println("其他异常");
}

6.3 try-with-resources

Java 7 引入的 try-with-resources 可以自动关闭实现了 AutoCloseable 的资源,避免忘记在 finally 中释放资源。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesDemo {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("读取文件失败:" + e.getMessage());
        }
    }
}

七、throw 与 throws 的区别

  • throw:用在方法体内,抛出一个具体的异常对象,一次只能抛一个。
  • throws:用在方法签名上,声明该方法可能抛出的异常类型,可以声明多个。
public class ThrowDemo {
    public static void checkAge(int age) throws IllegalArgumentException {
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数:" + age);
        }
        System.out.println("年龄合法:" + age);
    }

    public static void main(String[] args) {
        checkAge(-1);
    }
}

八、自定义异常

当 JDK 内置异常无法准确表达业务语义时,可以自定义异常。通常继承 RuntimeException(非受检)或 Exception(受检),并提供带 message 和 cause 的构造方法。

public class BusinessException extends RuntimeException {
    private final String errorCode;

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

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

    public String getErrorCode() {
        return errorCode;
    }
}

使用示例:

public class OrderService {
    public void createOrder(String userId, int amount) {
        if (userId == null || userId.isEmpty()) {
            throw new BusinessException("USER_EMPTY", "用户 ID 不能为空");
        }
        if (amount <= 0) {
            throw new BusinessException("AMOUNT_INVALID", "订单金额必须大于 0");
        }
        System.out.println("订单创建成功");
    }
}

九、异常链与包装

在分层架构中,底层异常往往需要转换为上层可理解的异常,此时应保留原始异常作为 cause,形成异常链,方便排查根因。

public class Repository {
    public String load(String path) {
        try {
            return new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(path)));
        } catch (java.io.IOException e) {
            throw new BusinessException("LOAD_FAILED", "加载文件失败:" + path, e);
        }
    }
}

这样在日志中可以看到「LOAD_FAILED」的同时,也能追溯到最初的 IOException。

十、异常处理的最佳实践

  1. 不要吞异常:空的 catch 块会隐藏问题,至少记录日志或重新抛出。
  2. 捕获具体异常:优先捕获明确的异常类型,避免直接 catch (Exception e) 一把抓。
  3. 尽早失败:参数校验不通过时立即抛出异常,避免错误向下扩散。
  4. 保留异常链:包装异常时传入 cause,不要只传 message。
  5. 不要在 finally 中 return:会覆盖 try 中的返回值,甚至吞掉异常。
  6. 异常信息要可读:message 中带上关键参数,便于定位问题。
  7. 区分业务异常与系统异常:业务异常用于可预期的流程分支,系统异常用于不可预期的故障。

十一、总结

Java 异常体系以 Throwable 为根,分为 Error 和 Exception 两大分支;Exception 又分为受检异常与非受检异常。掌握它们的继承关系、语义差异和处理方式,是写出健壮 Java 程序的基础。在实际开发中,应遵循「该捕获的捕获、该抛出的抛出、该修复的修复」的原则,配合自定义异常和异常链,让错误处理既清晰又可追溯。

使用小程序,查看更多面试题目,随时随地刷题,刷题更方便!

​编辑

​