Java基础-异常

顶层基类（$\text {Throwable}$），包含两个直接子类：

• 错误（$\text {Error}$）：程序无法处理的严重问题，应用程序一般无需捕获。
• 异常（$\text {Exception}$）：程序可以处理的异常，分为运行时异常和非运行时异常。

---

• 检查异常（$\text {Checked Exceptions}$）：编译器要求必须处置的异常。

  • 除了 RuntimeException 及其子类以外，其他的 Exception 类及其子类。

• 非检查异常（$\text {Unchecked Exceptions}$）：编译器不要求强制处置的异常。

  • RuntimeException 及其子类。
  • Error

非检查异常可以不处理，但运行时可能会抛出。检查异常必须捕获或抛出，否则会导致编译错误。

1. 捕获检查异常

try {
    // 可能抛出检查异常的代码
} catch (IOException e) {
    // 处理异常
}

1. 抛出检查异常

public void readFile() throws IOException {
    // 可能抛出检查异常的代码
}

关于捕获异常的方法通常有：

• try-catch
• try-catch-finally
• try-finally
• try-with-resource

---

try-catch：可以捕获多个异常类型，并对不同类型的异常做出不同的处理。

try-catch-finally：可以捕获多个异常类型，并对不同类型的异常做出不同的处理，无论是否发生异常，都会执行 finally 块，可以确保程序在发生异常时依然能够安全地释放资源并继续运行。

try-finally：一般用在不需要捕获异常的代码，可以保证资源使用后被关闭。

public static void main(String[] args) {
    FileWriter writer = null;
    try {
        writer = new FileWriter("file.txt");
        writer.write("Hello, try-finally!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (writer != null) {
                writer.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

try-with-resource：Java 7 引入，可以自动关闭资源，前提是资源实现了 AutoCloseable 接口。

public static void main(String[] args) {
    try (FileWriter writer = new FileWriter("file.txt")) {
        writer.write("Hello, try-with-resources!");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

阿里巴巴开发手册：【强制】Java 类库中定义的可以通过预检查方式规避的 RuntimeException 异常不应该通过 catch 的方式来处理，比如：NullPointerException，IndexOutOfBoundsException 等等。

:white_check_mark:推荐

if (obj != null) {
    // ...
}

:negative_squared_cross_mark:不推荐

try {
    obj.method();
} catch (NullPointerException e) {
    //...
}

优先捕获最具体的异常，例如 NumberFormatException 是 IllegalArgumentException 子类，需要先捕获 NumberFormatException，再捕获 IllegalArgumentException。

try {
    // ...
} catch (NumberFormatException e) {
    // ...
} catch (IllegalArgumentException e) {
    // ...
}

不要捕获 Throwable，Throwable 是所有异常和错误的超类。可能抛出不应该由应用程序处理的严重问题，是由程序控制之外的情况引起的，无法处理。

不要忽视异常，至少要通过日志记录异常信息。但是也不要捕获异常之后只是日志记录异常信息就抛出异常，会给同一个异常输出多条日志信息，可以将异常包装为自定义异常。

异常表（Exception Table）是 JVM 处理异常的核心机制，每个异常表项包含 4 个关键信息：

• fro：可能发生异常的起始点
• to：可能发生异常的结束点
• target：异常处理的跳转位置
• type：能处理的异常类型

package com.solisamicus;

public class Example {
    public static void testNPE() {
        String str = null;
        str.length(); // NullPointerException
    }

    public static void simpleTryCatch() {
        try {
            testNPE();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        simpleTryCatch();
    }
}

$ javap -c Example
警告: 二进制文件Example包含com.solisamicus.Example
Compiled from "Example.java"
public class com.solisamicus.Example {
  public com.solisamicus.Example();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void testNPE();
    Code:
       0: aconst_null
       1: astore_0
       2: aload_0
       3: invokevirtual #2                  // Method java/lang/String.length:()I
       6: pop
       7: return

  public static void simpleTryCatch();
    Code:
       0: invokestatic  #3                  // Method testNPE:()V
       3: goto          11
       6: astore_0
       7: aload_0
       8: invokevirtual #5                  // Method java/lang/Exception.printStackTrace:()V
      11: return
    Exception table:
       from    to  target type
           0     3     6   Class java/lang/Exception

  public static void main(java.lang.String[]);
    Code:
       0: invokestatic  #6                  // Method simpleTryCatch:()V
       3: return
}

主要关注 public static void simpleTryCatch() 方法，

Code 部分：左边数字是字节码的位置（偏移量），中间是 JVM 指令，右边是注释。

具体指令解释：

• 0: invokestatic #3：调用静态方法 testNPE()
• 3: goto 11：跳转到位置 11
• 6: astore_0：将异常对象存储到局部变量表的第 0 个位置
• 7: aload_0：加载局部变量表中第 0 个位置的值（异常对象）
• 8: invokevirtual #5：调用异常对象的 printStackTrace() 方法
• 11: return：方法返回

Exception table 部分：

• from：监控的代码起始位置（0）
• to：监控的代码结束位置（3）
• target：如果发生异常跳转到的位置（6）
• type：处理的异常类型（Exception）

正常情况：0 $\rightarrow$ 3 $\rightarrow$ 11（结束）

发生异常时：0 $\rightarrow$ 6 $\rightarrow$ 7 $\rightarrow$ 8 $\rightarrow$ 11（结束）

package com.solisamicus;

public class Example {
    public static void testNPE() {
        String str = null;
        str.length(); // NullPointerException
    }

    public static void simpleTryCatch() {
        try {
            testNPE();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("Finally");
        }
    }

    public static void main(String[] args) {
        simpleTryCatch();
    }
}

$ javap -c Example
警告: 二进制文件Example包含com.solisamicus.Example
Compiled from "Example.java"
public class com.solisamicus.Example {
  public com.solisamicus.Example();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void testNPE();
    Code:
       0: aconst_null
       1: astore_0
       2: aload_0
       3: invokevirtual #2                  // Method java/lang/String.length:()I
       6: pop
       7: return

  public static void simpleTryCatch();
    Code:
       0: invokestatic  #3                  // Method testNPE:()V
       3: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       6: ldc           #5                  // String Finally
       8: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      11: goto          41
      14: astore_0
      15: aload_0
      16: invokevirtual #8                  // Method java/lang/Exception.printStackTrace:()V
      19: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      22: ldc           #5                  // String Finally
      24: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      27: goto          41
      30: astore_1
      31: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      34: ldc           #5                  // String Finally
      36: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      39: aload_1
      40: athrow
      41: return
    Exception table:
       from    to  target type
           0     3    14   Class java/lang/Exception
           0     3    30   any
          14    19    30   any

  public static void main(java.lang.String[]);
    Code:
       0: invokestatic  #9                  // Method simpleTryCatch:()V
       3: return
}

主要关注 public static void simpleTryCatch() 方法，

Code 部分：

具体指令解释：

• try 块：
  • 0: invokestatic #3：调用静态方法 testNPE()
  • 3: getstatic #4：获取 System.out
  • 6: ldc #5：加载字符串常量 “Finally”
  • 8: invokevirtual #6：调用 println 方法
  • 11: goto 41：跳转到位置 41
• catch Exception 块：
  • 14: astore_0：存储捕获的异常
  • 15: aload_0：加载异常对象
  • 16: invokevirtual #8：调用异常对象的 printStackTrace() 方法
  • 19: getstatic #4：获取 System.out
  • 22: ldc #5：加载字符串常量 “Finally”
  • 24: invokevirtual #6：调用 println 方法
  • 27: goto 41：跳转到位置 41
• finally 块：
  • 30: astore_1：存储任何类型的异常
  • 31: getstatic #4：获取 System.out
  • 34: ldc #5：加载字符串常量 “Finally”
  • 36: invokevirtual #6：调用 println 方法
  • 39: aload_1：重新加载异常
  • 40: athrow：重新抛出异常
  • 41: return：方法返回

Exception table 部分：

• 0-3, 14, Exception：如果在位置 0-3 之间发生 Exception 类型的异常，跳转到位置 14 处理；

• 0-3, 30, any：如果在位置 0-3 之间发生任何异常，跳转到位置 30 处理；

• 14-19, 30, any：如果在位置 14-19 之间发生任何异常，跳转到位置 30 处理。

正常执行：0 $\rightarrow$ 3 $\rightarrow$ 6 $\rightarrow$ 8 $\rightarrow$ 11$\rightarrow$ 41（结束）

public static void testNPE() {
    System.out.println("Hello World!");
}

public static void simpleTryCatch() {
    try {
        testNPE();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("Finally");
    }
}

Hello World
Finally

捕获 Exception 类型的异常：0 $\rightarrow$ 14 $\rightarrow$ 15 $\rightarrow$ 16 $\rightarrow$ 19 $\rightarrow$ 22 $\rightarrow$ 24 $\rightarrow$ 27 $\rightarrow$ 41（结束）

public static void testNPE() throws Exception {
    throw new Exception("Exception");
}

public static void simpleTryCatch() {
    try {
        testNPE();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("Finally");
    }
}

java.lang.Exception: Exception
	at com.solisamicus.Example.testNPE(Example.java:5)
	at com.solisamicus.Example.simpleTryCatch(Example.java:10)
	at com.solisamicus.Example.main(Example.java:19)
Finally

捕获非 Exception 类型的异常：0 $\rightarrow$ 30 $\rightarrow$ 31 $\rightarrow$ 34 $\rightarrow$ 36 $\rightarrow$ 39 $\rightarrow$ 40 $\rightarrow$ 41

public static void testNPE(){
    throw new Error("Error");
}

public static void simpleTryCatch() {
    try {
        testNPE();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("Finally");
    }
}

Finally
Exception in thread "main" java.lang.Error: Error
	at com.solisamicus.Example.testNPE(Example.java:5)
	at com.solisamicus.Example.simpleTryCatch(Example.java:10)
	at com.solisamicus.Example.main(Example.java:19)