• 讲一下 RunTimeException 的造成的原因「非检查型异常」，并说一下为什么不处理 RunTimeException？
  • 有很多常见的异常，如数组越界或者使用了null引用，都属于非检查异常，编译器并不期望你为这些异常提供处理器。毕竟，你应该集中精力避免这些错误的发生，即使存在被忽视的非检查型异常，在编译时也可以发现。

    RuntimeException是Exception子类。而Exception还有其它类型的异常，我们统一称为非Runtime异常。RuntimeException的特点是非检查型异常，也就是Java系统中允许可以不被catch，在运行时抛出。而其它定非运行时异常如果抛出的话必须显示的catch，否则编译不过。 RuntimeException常见异常： 1 NullPointerException，空指针异常。 2 NumberFormatException，字符串转化成数字时。 3 ArrayIndexOutOfBoundsException， 数组越界时。 4 StringIndexOutOfBoundsException， 字符串越界时。 5 ClassCastException，类型转换时。 6 UnsupportedOperationException，该操作不支持，一般子类不实现父类的某些方法时。 7 ArithmeticException，零作为除数等。 8 IllegalArgumentException，表明传递了一个不合法或不正确的参数 运行时出现错误，说明你的代码有问题，程序已经无法继续运行，所以对RuntimeException的处理时不必要的。之所以不处理，目的就是要是程序停止，修正代码。

1 什么是异常？

  • 异常的定义

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。

  • 产生异常的原因

异常发生的原因有很多，通常包含以下几大类

  • 用户输入了非法数据。
  • 要打开的文件不存在。
  • 网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。

  • 异常处理机制

Java提供了异常处理机制，能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

  • 异常类

Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过**throw**语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常类来封装异常，然后JRE就会试图寻找异常处理程序来处理异常。

  • **Throwable**类是Java异常类型的顶层父类，一个对象只有是**Throwable**类的（直接或者间接）实例，他才是一个异常对象，才能被异常处理机制识别。
  • Java标准库提供了一些常用的异常类，我们也可以自定义异常。

2 Java中的异常

  • Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。

点击查看【processon】

  • Throwable派生出Error类和Exception类，分别对应错误和异常

错误

  • Error类以及他的子类的实例，代表了JVM本身的错误。
  • Java程序不捕获错误。
  • 错误一般发生在严重故障时，它们在Java程序处理的范畴之外，不能被程序员通过代码处理。
  • 程序一般不会从错误中恢复

例如，当栈溢出时，一个错误就发生了，这是无法被javac检查到的。
异常

  • Exception以及他的子类，代表程序运行时发生的各种不期望发生的事件。
  • 可以被Java异常处理机制使用，是异常处理的核心。
  • 程序员应该关注**Exception**为父类的分支下的各种异常类。
  • 根据对异常的处理要求，可以将异常分为两类

非检查异常（unckecked exception）

  • 非检查异常包括**Error**和**RuntimeException**（运行时异常）以及他们的子类
  • javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常
  • 我们可以编写代码处理（使用try...catch...finally）这样的异常，也可以不处理

但是非检查异常发生的原因多半是代码写的有问题，大多数情况下，我们应该修正代码，而不是去通过异常处理器处理非检查异常。

  • 发生**RuntimeException**，即代码运行时出现错误，说明代码有问题，程序已经无法继续运行，所以对**RuntimeException**的处理是不必要的。之所以不处理，目的就是要是程序停止，修正代码。
  • 非检查异常如除0异常**ArithmeticException**、错误的强制类型转换错误**ClassCastException**、数组索引越界**ArrayIndexOutOfBoundsException**、使用了空对象**NullPointerException**等等。
  • 非检查异常默认是自动向外抛出的（throws子句），直到抛出到系统层面报错

因此对于某些不想因为非检查异常而影响系统运行的情况，需要通过异常处理器处理非检查异常

检查异常（checked exception）

  • 除了Error和RuntimeException的其它异常，javac强制要求程序员为这样的异常做预备处理工作，在方法中要么用**try-catch**语句捕获它并处理，要么用**throws**子句声明抛出它，否则编译不会通过。
  • 检查异常一般是由程序的运行环境导致的，因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，检查异常是程序员无法预见的，例如要打开一个不存在文件时，一个异常就发生了，于是程序员就应该为这样的异常时刻准备着。
  • 检查异常如**SQLException**、**IOException**、**ClassNotFoundException**、**FileNotFoundException**等。

需要明确的是：检查和非检查是对于javac来说的，这样就很好理解和区分了。

3 异常触发的过程

  • 先看下面代码，是一个除法计算器，在命令行输入除数和被除数

    1. public class MyClass {
    2.   public static void main(String[] args) {
    3.       System.out.println("----欢迎使用命令行除法计算器----");
    4.       CMDCalculate();
    5.   }
    7.   public static void CMDCalculate() {
    8.       Scanner scan = new Scanner(System.in);
    9.       System.out.print("请输入被除数和除数：");
    10.       int num1 = scan.nextInt();    //此处可能触发InputMismatchException
    11.       int num2 = scan.nextInt();    //此处可能触发InputMismatchException
    12.       int result = divide(num1, num2);    
    13.       System.out.println("result:" + result);
    14.       scan.close();
    15.   }
    17.   public static int divide(int num1, int num2) {
    18.       return num1 / num2;    //此处可能触发ArithmeticException
    19.   }
    20. }

  • 下面输入相应的数据，引发两个异常类型：ArithmeticException和InputMismatchException（都是非检查异常），前者由于整数除0引发，后者是输入的数据不能被转换为int类型引发。 ``` ——欢迎使用命令行除法计算器—— 请输入被除数和除数：2 0 Exception in thread “main” java.lang.ArithmeticException: / by zero at PersonalTest.MyClass.divide(MyClass.java:21) at PersonalTest.MyClass.CMDCalculate(MyClass.java:15) at PersonalTest.MyClass.main(MyClass.java:7)

进程已结束，退出代码 1

——欢迎使用命令行除法计算器—— 请输入被除数和除数：1 K Exception in thread “main” java.util.InputMismatchException at java.base/java.util.Scanner.throwFor(Scanner.java:939) at java.base/java.util.Scanner.next(Scanner.java:1594) at java.base/java.util.Scanner.nextInt(Scanner.java:2258) at java.base/java.util.Scanner.nextInt(Scanner.java:2212) at PersonalTest.MyClass.CMDCalculate(MyClass.java:14) at PersonalTest.MyClass.main(MyClass.java:7)

进程已结束，退出代码 1

  2. - **异常触发过程**
  3.    - 异常是在执行某个函数时引发的，而函数又是层级调用，形成调用栈的。因此，**只要一个函数发生了异常，那么他的所有的caller都会被异常影响**。
  4.       - **当这些被影响的函数以异常信息输出时，就形成的了异常追踪栈**。
  5.       - **异常最先发生的地方，叫做异常抛出点。**
  7. - **对上述产生的**`**ArithmeticException**`**进行分析，如下**
  9. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/1169704/1616744553666-4be81258-f87d-4564-b79b-3c92b8e0e784.png#crop=0&crop=0&crop=1&crop=1&height=222&id=qBrxV&name=image.png&originHeight=222&originWidth=723&originalType=binary&ratio=1&rotation=0&showTitle=false&size=54373&status=done&style=none&title=&width=723)
  11.    - 当`devide()`发生除0异常时，`devide()`将抛出`ArithmeticException`异常，因此调用他的`CMDCalculate()`也无法正常完成，因此也发送异常，而`CMDCalculate()`的caller——`main()`因为`CMDCalculate()`抛出异常，也发生了异常。
  12.    - **异常的冒泡**
  14. 上述这样一直向调用栈的栈底回溯行为叫做**异常的冒泡。**<br />**异常的冒泡是为了在当前发生异常的函数或者这个函数的caller中找到最近的异常处理程序。**
  16.       - **由于这个例子中没有使用任何异常处理机制（也不应该有）**，因此**异常最终由**`**main()**`**函数抛给JRE，导致程序终止**。
  18. - 上面的例子不使用异常处理机制，也可以顺利编译，因为两个异常都是非检查异常。
  20. **但是下面的例子就必须使用异常处理机制，因为异常都是检查异常。**
  21. ```java
  22. public void testException() throws IOException {
  23.     //FileInputStream的构造函数会抛出FileNotFoundException
  24.     FileInputStream fileIn = new FileInputStream("E:\\a.txt");
  26.     int word;
  27.     //read方法会抛出IOException
  28.     while ((word = fileIn.read()) != -1) {
  29.         System.out.print((char) word);
  30.     }
  31.     //close方法会抛出IOException
  32.     fileIn.close();
  33. }
  • 代码中选择使用throws声明异常，让函数的caller去处理可能发生的异常。但是为什么只throws了IOException呢？因为FileNotFoundException是IOException的子类，在处理范围内。

4 处理异常的方法

  • 在编写代码处理异常时，对于检查异常，有2种不同的处理方式
    • 使用try...catch...finally语句块处理它。
    • 在函数签名中使用throws声明交给函数的caller去解决。

1 try…catch…finally语句块

  • 语法格式

    1. try {
    2.   ...
    3. } catch (Exception exception) {
    4.   ...
    5. } finally {
    6.   ...
    7. }

  • try块

    • try块中放可能发生异常的代码。
    • 如果执行完try且不发生异常，则接着去执行finally块和finally后面的代码。
    • 如果发生异常，则尝试去匹配catch块。

  • catch块

    • 每一个catch块用于捕获并处理一个特定类型的异常，或者该异常类型的子类。

    • catch后面的括号定义了异常参数，在catch块中可以使用这个块的异常参数来获取异常的相关信息。

异常参数是这个catch块中的局部变量，其它块不能访问。

  • 一个try块下可以有多个catch块，即多重捕获块，用于处理不同的异常

异常匹配是按照catch块的顺序从上往下寻找的，只有第一个匹配的catch会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配，因此，如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。

  • 如果try中没有发生异常，则所有的catch块将被忽略。

  • 如果当前try块中发生的异常在后续的所有catch块都没捕获到，则先去执行finally块，然后到这个函数的外部caller中去匹配异常处理器。

  • catch块内部一般执行Exception类的实例方法**exception.printStackTrace()**，用于将Throwable对象和堆栈轨迹打印到标准错误流。

  • finally块

    • finally块是可选的。

    • 无论异常是否发生，以及发生异常后catch块是否匹配异常，只要对应的try执行了，finally块就一定会执行。

只有一种方法让finally块不执行：System.exit()。

  • finally块主要做一些清理工作，如流的关闭，数据库连接的关闭等。

良好的编程习惯是：在try块中打开资源，在finally块中清理释放这些资源。

  • 一个try块至少要有一个catch块，否则，至少要有1个finally块（可以没有catch块）。

但是finally块不是用来处理异常的，finally块不会捕获异常。

  • 在同一try…catch…finally块中 ，如果try中抛出异常，且有匹配的catch块，则先执行catch块，再执行finally块。如果没有catch块匹配，则先执行finally，然后去外面的caller中寻找合适的catch块。

在同一try…catch…finally块中 ，try发生异常，且匹配的catch块中处理异常时也抛出异常，那么后面的finally也会执行：首先执行finally块，然后去外围caller中寻找合适的catch块。

  • 关于三个函数块的局部变量

try块中的局部变量、catch块中的局部变量（包括异常变量）以及finally块中的局部变量，是不可共享使用的。

  • try…catch…finally语句块的执行流

Java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。

  • 有的编程语言当异常被处理后，控制流会恢复到异常抛出点接着执行，这种策略叫做：resumption model of exception handling（恢复式异常处理模式 ）
  • 而Java则是让执行流恢复到处理了异常的catch块后接着执行，这种策略叫做：termination model of exception handling（终结式异常处理模式）

2 throws函数声明

  • throws定义

throws是另一种处理异常的方式，它不同于try…catch…finally，throws仅仅是将函数中可能出现的异常向caller声明，或者说是抛给caller，使用外围caller的catch块处理，而自己则不具体处理。

  • throws语法格式

    1. public void fun() throws ExceptionType1, ExceptionType2, ..., ExceptionTypeN
    2. { 
    3.    //fun内部可以抛出ExceptionType1, ExceptionType2, ..., ExceptionTypeN类的异常，
    4.    //或者他们的子类的异常对象。
    5. }

  • 采取这种异常处理的原因可能是：方法本身不知道如何处理这样的异常，或者说让caller处理更好，调用者需要为可能发生的异常负责。

  • 如果一个方法内部的代码会抛出检查异常（checked exception），而方法自己又没有办法处理掉，则必须在方法的签名上使用throws关键字声明这些可能抛出的异常，否则编译不通过。

    • 非检查异常，throws关键字声明不是必要的

  • 异常层层递交，最终要是连**main()**方法都**throws Exception**了，那就交由java虚拟机处理，一般是打印异常信息

5 手动抛出异常

  • 根据需要，程序员可以通过throw语句手动显式地抛出一个异常。

    • 手动抛出异常时，可以手动给异常添加额外的提示信息。
    • throw 语句必须写在函数中，执行throw语句的地方就是一个异常抛出点，它和由JRE自动形成的异常抛出点没有任何差别。

  • throw语句格式

throw语句的后面必须是一个异常对象

  1. throw exceptionObject

  • 实例

    1. public void save(User user)
    2. {
    3.   if(user  == null) 
    4.       throw new IllegalArgumentException("User对象为空");
    6.   ...    
    7. }

6 异常的链化

  • 在一些大型的，模块化的软件开发中，一旦一个地方发生异常，则如骨牌效应一样，将导致一连串的异常。

    • 假设B模块完成自己的逻辑需要调用A模块的方法，如果A模块发生异常，则B也将不能完成而发生异常，但是B在抛出异常时，会将A的异常信息掩盖掉，这将使得异常的根源信息丢失。
    • 异常的链化则可以将多个模块的异常串联起来，使得异常信息不会丢失。

  • 异常链化的定义

以一个异常对象为参数构造新的异常对象，新的异对象将包含先前异常的信息。

  • 异常链化的实现

主要是通过各异常类的构造函数中，一个Throwable类型的参数cause实现的。
这个当做参数的异常（所有异常的顶层父类），我们叫他根源异常（cause）。

  • 例如IOException类的一个构造函数：

    1. public IOException(String message, Throwable cause) {
    2. super(message, cause);
    3. }

  • 带Throwable类型参数的方法，最后总是调用顶层父类Throwable的相应带Throwable类型参数的方法，如上述方法最后调用的是Throwable类的一个构造函数

    1. public Throwable(String message, Throwable cause) {
    2. fillInStackTrace();
    3. detailMessage = message;
    4. this.cause = cause;
    5. }

  • 查看Throwable类源码，可以发现里面有一个Throwable字段cause，就是它保存了构造时传递的根源异常参数。这种设计和链表的结点类设计如出一辙，因此形成链也是自然的了。

    1. public class Throwable implements Serializable {
    2.   private Throwable cause = this;
    4.   //构造Throwable时，传入根源异常，形成异常链表
    5.   public Throwable(String message, Throwable cause) {
    6.       fillInStackTrace();
    7.       detailMessage = message;
    8.       this.cause = cause;
    9.   }
    10.   //构造Throwable时，传入根源异常，形成异常链表
    11.    public Throwable(Throwable cause) {
    12.       fillInStackTrace();
    13.       detailMessage = (cause==null ? null : cause.toString());
    14.       this.cause = cause;
    15.   }
    17.   ...
    18. }

  • 异常的链化实例

下方代码实现从命令行输入2个int型数值，将他们相加，输出。
如果输入的数不是int类型，则导致getInputNumbers()函数异常，从而导致add()函数异常，则可以在add()函数中抛出

  • 执行异常的**printStackTrace()**方法可以输出异常链，否则没有任何输出

    1. public class MyClass {
    2. public static void main(String[] args) {
    3.    System.out.println("请输入2个整型加数");
    4.    int result;
    5.    try {
    6.        result = add();
    7.        System.out.println("结果:" + result);
    8.    } catch (Exception e) {
    9.        e.printStackTrace();
    10.    }
    11. }
    13. //获取输入的2个整数返回
    14. private static List<Integer> getInputNumbers() throws InputMismatchException {
    15.    List<Integer> nums = new ArrayList<>();
    16.    Scanner scan = new Scanner(System.in);
    18.    int num1 = scan.nextInt();
    19.    int num2 = scan.nextInt();
    20.    nums.add(num1);
    21.    nums.add(num2);
    23.    scan.close();
    24.    return nums;
    25. }
    27. //执行加法计算
    28. private static int add() throws Exception {
    29.    int result;
    30.    try {
    31.        List<Integer> nums = getInputNumbers();
    32.        result = nums.get(0) + nums.get(1);
    33.    } catch (InputMismatchException immExp) {
    34.        throw new Exception("计算失败", immExp);    //传入根源异常immExp
    35.    }
    36.    return result;
    37. }
    38. }
  • 上述代码输出
    1. java.lang.Exception: 计算失败
    2.   at PersonalTest.MyClass.add(MyClass.java:47)
    3.   at PersonalTest.MyClass.main(MyClass.java:16)
    4. Caused by: java.util.InputMismatchException
    5.   at java.base/java.util.Scanner.throwFor(Scanner.java:939)
    6.   at java.base/java.util.Scanner.next(Scanner.java:1594)
    7.   at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
    8.   at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
    9.   at PersonalTest.MyClass.getInputNumbers(MyClass.java:28)
    10.   at PersonalTest.MyClass.add(MyClass.java:44)
    11.   ... 1 more

7 自定义异常

  • 如果要自定义异常类，则扩展**Exception**类即可，因为自定义的异常一般都属于检查异常。

如果要自定义非检查异常，则应扩展自**RuntimeException**。

  • 按照国际惯例，自定义的异常应该总是包含如下的构造函数：

    • 一个无参构造函数
    • 一个带有String类型参数的构造函数，并传递给父类的构造函数。
    • 一个带有**String**类型参数和**Throwable**类型参数，并都传递给父类构造函数
    • 一个带有Throwable类型参数的构造函数，并传递给父类的构造函数。

  • 下面是IOException类的完整源代码，可以借鉴。 ```java public class IOException extends Exception { static final long serialVersionUID = 7818375828146090155L;

    public IOException() {

    1.   super();

    }

    public IOException(String message) {

    1.   super(message);

    }

    public IOException(String message, Throwable cause) {

    1.   super(message, cause);

    }

  1. public IOException(Throwable cause)
  2. {
  3.     super(cause);
  4. }

} ```

8 异常与继承

  • 当子类重写父类的带有throws声明的函数时
    • 子类重写的方法，其throws声明的异常必须在父类异常的可控范围内

也就是说，用于处理父类的throws方法的异常处理器，必须也适用于子类的这个带throws方法 。

  • 这是为了支持多态。
  • 例如
    • 父类方法**throws**的是2个异常，子类就不能**throws**3个及以上的异常。
    • 父类**throws IOException**，子类就必须**throws IOException**或者**IOException**的子类。

9 异常与多线程

  • Java程序可以是多线程的。每一个线程都是一个独立的执行流，独立的函数调用栈。

    • 如果程序只有一个线程，那么没有被任何代码处理的异常会导致程序终止。
    • 如果是多线程的，那么没有被任何代码处理的异常仅仅会导致异常所在的线程结束。

  • Java中的异常是线程独立的

    • 线程的问题应该由线程自己来解决，而不要委托到外部，
    • 线程出现没有被处理的异常，也不会直接影响到其它线程的执行。

10 关于finally块

  • finally块内的代码/异常/return等，总是会执行

  • 有以下规则

    • 在try块和catch块中即便有return，break，continue等改变执行流的语句，finally块也会执行。

    • finally中的return会覆盖try块或者catch块中的返回值

    • finally中的return会抑制（消灭）前面try块或者catch块中的异常

    • finally中的异常会覆盖（消灭）前面try块或者catch块中的异常

  • 由于上述规则，我们在编写代码时

    • 不要在fianlly块中使用**return**，尽量将所有的return写在函数的最后面，而不是try … catch … finally中
    • 不要在finally块中抛出异常
    • 减轻finally块的任务，不要在finally块中做一些其它的事情，finally块仅仅用来释放资源是最合适的。