异常 - 深入理解Java中的异常体系

- 日理万妓 2023-10-14 10:51 31阅读 0赞

## 1.为什么要使用异常 ##

使用异常是一种处理程序运行时错误和异常情况的有效机制，它具有以下几个优势：

错误隔离：异常可以将正常代码与错误处理逻辑分离开来。当出现异常时，可以通过捕获异常并在适当的位置处理它们，而不会影响正常代码的执行流程，从而实现错误隔离。
    
    提高代码可读性：使用异常可以使代码更加简洁和易读。通过将错误处理逻辑移到 catch 块中，可以将关键业务逻辑与错误处理分开，使得代码结构更清晰。
    
    集中错误处理：异常的集中处理有助于代码的维护和管理。在程序中的一个地方处理异常，就可以处理多个可能出现的异常情况，避免在多个地方重复处理相同的异常。
    
    传递错误信息：异常对象携带了错误信息和异常堆栈信息，这些信息可以帮助开发人员定位问题，并进行合适的调试和修复。
    
    灵活性：异常处理机制允许在不同层级之间传递异常。如果某个方法不能处理自己捕获到的异常，可以通过 throw 关键字将异常抛出给调用方处理，从而实现更灵活的异常处理链。
    
    代码可靠性：合理地使用异常可以提高程序的健壮性和可靠性。通过处理异常，可以使程序在面对异常情况时进行优雅地降级或恢复，避免程序崩溃或产生不可预测的结果。

## 2、基本定义 ##

在 Java 中，异常是指在程序运行过程中可能出现的意外情况或错误。Java 中的异常是通过异常类的实例来表示的，异常类继承自 Throwable 类，它是所有异常类的根类。

在 Java 中，异常主要分为两类：可检查异常和运行时异常。

### 可检查异常： ###

可检查异常是指在代码中必须进行明确处理的异常，通常是由外部环境或资源导致的，比如文件不存在、网络连接失败、数据库访问异常等。可检查异常是 Throwable 的子类，但是它不是 RuntimeException 的子类。

可检查异常必须在方法的声明中或调用处进行处理，可以通过 try-catch 块来捕获和处理，或者使用 throws 关键字在方法签名中声明该异常可能被抛出，让调用方来处理。

### 运行时异常： ###

运行时异常是指编程错误或逻辑错误导致的异常，通常是由程序员编码不当造成的，比如空指针引用、数组索引越界、除以零等。运行时异常是 RuntimeException 的子类。

运行时异常不要求强制处理，可以选择捕获和处理，但并不强制要求。通常，运行时异常是由于代码的缺陷或错误造成的，应该在开发和测试阶段修复这些问题，而不是依赖于捕获运行时异常来处理错误。

## 3、体系结构 ##

在 Java 中，异常体系是由类继承关系构成的，所有异常类都是 Throwable 类或其子类。Throwable 类是所有异常类的根类，它派生出两个主要的子类：Error 和 Exception。异常体系的结构如下：

Throwable
        ├── Error
        │   ├── OutOfMemoryError
        │   ├── StackOverflowError
        │   └── ...
        └── Exception
            ├── IOException
            │   ├── FileNotFoundException
            │   ├── EOFException
            │   └── ...
            ├── RuntimeException
            │   ├── NullPointerException
            │   ├── IndexOutOfBoundsException
            │   │   ├── ArrayIndexOutOfBoundsException
            │   │   └── StringIndexOutOfBoundsException
            │   ├── ArithmeticException
            │   └── ...
            └── ...

Throwable：Throwable 是异常体系的根类，它是所有异常类的基类。Throwable 类有两个重要的子类：Error 和 Exception。Error 类表示严重的系统错误，通常由 JVM 抛出，程序无法处理；而 Exception 类表示程序运行中可能出现的异常情况，可以通过捕获和处理来恢复程序执行。
    
    Error：Error 类是 Throwable 类的子类，表示严重的系统错误，通常由 JVM 抛出。程序一般无法处理 Error，因为这些错误通常是由系统环境或硬件故障引起的，例如 OutOfMemoryError、StackOverflowError 等。
    
    Exception：Exception 是 Throwable 类的子类，表示程序运行中可能出现的异常情况。Exception 又分为可检查异常和运行时异常两类。
    
    IOException：IOException 是 Exception 的子类，表示输入输出异常，通常用于处理与文件、网络等 I/O 相关的异常。
    
    RuntimeException：RuntimeException 是 Exception 的子类，表示运行时异常，通常是由程序员编码不当导致的逻辑错误，例如空指针引用、数组索引越界、除以零等。

## 4、处理机制 ##

异常处理机制是一种程序运行时处理异常情况的机制，它允许程序在出现错误或异常时进行合理的响应和恢复，而不会导致程序的崩溃或不可预料的结果。Java 异常处理机制通过 try-catch 块来实现，具体如下：

抛出异常：当程序运行过程中发生异常或错误时，Java 会自动创建相应异常类的实例，并将该异常抛出，即抛出异常对象。
    
    捕获异常：为了避免异常导致程序崩溃，我们可以在代码中使用 try-catch 块来捕获异常。在 try 块中编写可能会抛出异常的代码，当异常发生时，程序会跳转到相应的 catch 块中，尝试捕获并处理该异常。
    
    处理异常：在 catch 块中，我们可以根据捕获的异常类型进行相应的处理。这可能包括记录日志、给用户友好的提示、回滚事务等操作，以确保程序的正常执行或优雅降级。
    
    finally 块：finally 块是可选的，在 try-catch 块后面，用于指定无论是否出现异常，都会执行的代码。通常在 finally 块中进行资源的释放和清理操作，以确保资源的正确释放。

Java 异常处理的基本语法结构如下：

try {
        
        // 可能抛出异常的代码
    } catch (ExceptionType1 e1) {
        
        // 处理 ExceptionType1 类型的异常
    } catch (ExceptionType2 e2) {
        
        // 处理 ExceptionType2 类型的异常
    } finally {
        
        // 无论是否抛出异常，都会执行的代码（可选）
    }

在这个结构中，try 块中编写可能抛出异常的代码。如果出现异常，程序会跳转到匹配的 catch 块中，处理相应类型的异常。如果没有匹配的 catch 块，异常会继续向上层调用方法传递，直到被捕获或传递给 JVM 处理。

总的来说，Java 异常处理机制允许我们将正常代码与错误处理逻辑分开，提高代码可读性、灵活性和可维护性。通过合理地使用异常处理，我们可以有效地处理程序运行中可能出现的异常情况，并保证程序的稳定性和可靠性。

## 5、关键字 ##

在 Java 中，异常处理和异常抛出相关的关键字有以下几个：

try: try 是异常处理语句的起始关键字。在 try 块中编写可能会抛出异常的代码段。
    
    catch: catch 是用于捕获并处理异常的关键字。在 catch 块中，可以根据捕获的异常类型来进行相应的处理。
    
    finally: finally 是可选的，用于指定无论是否发生异常，都会执行的代码。通常在 finally 块中进行资源的释放和清理操作。
    
    throw: throw 是用于抛出异常的关键字。在代码中可以使用 throw 关键字手动抛出异常对象。
    
    throws: throws 是用于声明方法可能抛出的异常类型的关键字。在方法的声明中可以使用 throws 关键字来指定该方法可能抛出的异常。
    
    try-with-resources: try-with-resources 是 Java 7 引入的语法，用于自动管理资源的关闭。在 try-with-resources 块中，可以打开一个或多个资源，并在代码块结束后自动关闭这些资源，无需显式调用 close() 方法。

在处理异常时，try-catch 块用于捕获并处理异常，try-with-resources 用于自动管理资源的关闭。throw 关键字用于手动抛出异常，而 throws 关键字用于声明可能抛出的异常，以通知调用者需要处理这些异常。finally 块通常用于释放资源或进行必要的清理操作，不管是否发生异常都会执行其中的代码。

## 6、throws ##

在 Java 中，throws 是一个用于方法声明的关键字，用于声明方法可能抛出的异常类型。当一个方法可能会引发某种异常情况时，可以使用 throws 关键字来告诉调用者，该方法可能抛出指定类型的异常，从而通知调用者需要处理这些异常。

使用 throws 关键字的方法声明形式如下：

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

在方法声明中，throws 后面跟着一个或多个异常类型，用逗号分隔。这些异常类型可以是当前方法可能抛出的检查异常（可检查异常是 Throwable 的子类，但不是 RuntimeException 的子类）。通常情况下，我们在方法声明中使用 throws 关键字来声明当前方法可能抛出的受检查异常。

调用一个声明了 throws 的方法时，有两种处理方式：

捕获异常: 可以使用 try-catch 块来捕获和处理方法抛出的异常。这样，在 try 块中调用可能抛出异常的方法，并在 catch 块中处理异常，以保证程序正常执行。
    
    继续抛出异常: 如果当前方法本身也不想处理异常，或者无法处理异常，并希望将异常传递给上一层调用者处理，可以在当前方法中使用 throw 关键字抛出捕获到的异常。这样，异常会继续向上层调用方法传递，直到被捕获或传递给 JVM 处理。

示例代码：

public void readFile() throws FileNotFoundException, IOException {
        
        try (FileInputStream fis = new FileInputStream("file.txt")) {
        
            // 读取文件内容
        } catch (FileNotFoundException e) {
        
            // 处理文件不存在异常
            throw e; // 继续抛出异常给调用者处理
        } catch (IOException e) {
        
            // 处理读取文件错误异常
            throw e; // 继续抛出异常给调用者处理
        }
    }

在上面的示例中，readFile() 方法声明了可能抛出 FileNotFoundException 和 IOException 两种异常。在方法体内，使用 try-catch 块来捕获这两种异常，并在 catch 块中处理异常。如果在 catch 块中无法处理异常，我们可以继续抛出异常给上层调用者处理。

## 7、throw ##

在 Java 中，throw 是一个关键字，用于手动抛出异常。通过 throw 关键字，我们可以在代码中创建并抛出异常对象，从而在程序的某个地方主动引发异常情况。这可以用于在方法中检测到错误或特殊情况，并将其表示为异常。

throw 的语法如下：

throw 异常对象;

在使用 throw 关键字时，需要提供一个异常对象，该对象必须是 Throwable 类或其子类的实例，表示要抛出的异常。

示例代码：

public void divide(int dividend, int divisor) throws ArithmeticException {
        
        if (divisor == 0) {
        
            throw new ArithmeticException("除数不能为零");
        }
        int result = dividend / divisor;
        System.out.println("结果：" + result);
    }

在上面的示例中，divide() 方法用于执行两个整数的除法运算。在方法体内，我们首先检查除数是否为零，如果除数为零，就会使用 throw 关键字手动抛出一个 ArithmeticException 异常对象，表示除数不能为零。如果除数不为零，则执行除法运算并输出结果。

在调用 divide() 方法时，如果除数为零，将会抛出 ArithmeticException 异常，并且该异常会继续向上层调用方法传递，直到被捕获或传递给 JVM 处理。

使用 throw 关键字能够帮助我们自定义异常情况，并将其转换为异常对象，从而在程序中明确表示出错或特殊情况。

## 8、注意事项 ##

在使用异常体系时，有一些注意事项需要考虑和遵守，以确保代码的稳定性和可维护性。以下是一些值得注意的事项：

捕获合适的异常类型：在使用 try-catch 块时，应该捕获合适的异常类型。避免使用过于宽泛的 catch 块，因为这可能会捕获不应该由当前代码处理的异常类型，导致处理不当。
    
    不滥用异常：异常处理机制不应该被滥用用于正常流程控制。异常应该用于处理意外情况和错误，而不是作为普通逻辑的替代品。普通的控制流程应该使用条件语句和返回值来处理。
    
    不忽略异常：避免将异常直接忽略掉，即空的 catch 块。这样会导致异常被吞没，无法被发现和处理，可能造成潜在的问题难以追踪。
    
    避免捕获通用异常：不要捕获通用的异常类，如 Exception，这会导致捕获所有可能的异常，包括运行时异常，使得问题难以定位和处理。
    
    抛出合适的异常：在自定义异常时，应该选择合适的异常类型，或者继承自现有的合适异常类型。这样有助于其他开发人员更好地理解异常的含义和处理方式。
    
    资源的释放：对于使用了资源（如文件、网络连接、数据库连接等）的代码，应该在适当的地方进行资源的释放和清理操作。一般在 finally 块中进行资源的关闭，以确保资源得到正确释放。
    
    谨慎处理 checked 异常：对于 checked 异常（可检查异常），必须进行明确的处理或者通过 throws 关键字声明在方法签名中。不要在方法签名中使用 throws 关键字声明 unchecked 异常（运行时异常）。
    
    避免在构造方法中抛出异常：避免在构造方法中抛出异常，因为这可能导致对象的创建失败，并且在调用方无法捕获构造方法中的异常。
    
    异常处理逻辑简洁：异常处理逻辑应该简洁明了，避免过多的嵌套或重复的代码，以保持代码的可读性和维护性。
    
    日志记录：在捕获和处理异常时，应该适时记录相关的日志信息，方便排查问题和调试。

**异常处理是线程独立的，不会影响其他线程的执行？**

是的，异常处理是线程独立的，不会影响其他线程的执行。每个线程在运行时都会有自己的执行栈（调用栈），包含方法调用和局部变量等信息。当一个线程在执行过程中发生异常时，异常处理会根据异常处理机制进行处理，而不会影响其他线程的正常执行。

具体来说，当某个线程发生异常时，异常会沿着方法调用链向上抛出，直到被捕获并在合适的地方进行处理。如果在当前线程的调用栈中找不到对应的 catch 块来处理异常，那么异常会继续向上层调用栈传递，直到找到合适的 catch 块或者最终传递给 Java 虚拟机（JVM）进行处理。

其他线程不受发生异常的线程影响，它们继续独立地执行自己的代码，不会受到异常的影响。即使在一个线程中发生了未捕获的异常，其他线程的执行不会受到影响，并且程序的其他部分仍然可以继续运行。

Java 中的线程是相互独立的，它们有自己的执行上下文和执行栈，异常在一个线程中被抛出和处理不会波及其他线程的执行。这就是为什么 Java 中的多线程编程要小心处理异常，确保每个线程能够正确地处理自己的异常，以避免对整个程序的影响。