异常体系

傷城~ 2022-11-06 07:56 131阅读 0赞

# 异常 #

异常一般指不期而至的各种状况，如：文件不存在、空指针、非法参数等。  
异常是一个事件，发生在程序运行期间，干扰了正常的指令流程。  
Java 中使用 Throwable 类及其子类来描述各种不同的异常。因此，Java 异常都是对象，是 Throwable 的子类实例，描述了出现在一段编码中的错误条件。当条件生成时，错误将引发异常。

Java 异常类层次结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70][]

从图上我们可以看到，Java 异常都继承自 Throwable，Throwable 分为两大派系，一类是 Error（错误），一类是 Exception（异常）。

### Error ###

Error `是程序员无法处理的错误`，表示运行应用程序中较严重的问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM 出现的问题。比如，Java 虚拟机运行时错误（VirtualMachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这时异常发生时，Java 虚拟机一般会终止线程。

所以这一类异常我们一般不用太纠结。

### Exception ###

这是程序本身可以处理的异常。  
Exception 有一个非常重要的子类 **RuntimeException**，RuntimeException 类及其子类表示 JVM 常用操作引发的错误，例如空值对象引用、除数为零、数组角标越界则分别会引发 NullPointException、ArithmeticException、ArrayIndexOutOfBoundException。

敲黑板！！分清异常和错误的区别，异常是可以被程序本身处理的，错误不能。

### 可查异常 ###

> 又称编译时异常，是编译器要求必须处置的异常。  
> 正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

**除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。**

### 不可查异常 ###

> 编译器不要求强制处置的异常，包括运行时异常（RuntimeException）和错误（Error）。

### 运行时异常 ###

都是 RuntimeException 类及其子类。

`这些异常是不检查异常`，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序**应该从逻辑角度尽可能避免**这类异常的发生。

### 编译时异常 ###

是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。

# 处理异常机制 #

遇到异常怎么办？要么自己想办法处理，要么就抛给别人。

抛出异常：  
当一个方法出现错误引发异常时，方法创建异常对象并交付给运行时系统，系统对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

捕获异常：  
在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（Exception handler）。**潜在的异常处理是异常发生时依次存留在调用栈中的方法的集合**。当异常处理器所能处理的异常类型与抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有异常处理器的方法并执行。当运行时系统遍历了调用栈都没找到合适的异常处理器，则运行时系统终止，Java 程序终止。

对于运行时异常、错误和可查异常，Java 要求的异常处理方式有所不同。

*  对于方法运行中可能出现的 Error，当运行方法不能捕捉时，Java 允许该方法不做任何抛出声明。因为大多数 Error 异常属于永远不允许发生的情况，也属于合理的应用程序不挂捕获的异常。
 *  对于所有可查异常，Java 规定：一个方法必须捕捉或者声明抛出。

能够捕捉异常的方法，需要提供相符类型的异常处理器。也就是说，`一个方法所能捕获的异常，一点是 Java 代码在某处所抛出的异常`。

任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。

从方法中抛出的任何异常都必须使用throws子句。

捕捉异常通过try-catch语句或者try-catch-finally语句实现。

**总结来书。Java 规定：对于可查异常必须捕捉、或者声明抛出。运行忽略不可查的 RuntimeException 和 Error。**

### 捕获异常 try、catch 和 finally ###

*  首先是 try-catch 语句

基本语法如下：

try {  
        // 可能会发生异常的程序代码  
    } catch (Type1 id1){  
        // 捕获并处置try抛出的异常类型Type1  
    } catch (Type2 id2){  
         //捕获并处置try抛出的异常类型Type2  
    }复制代码

关键词 try 后面的大括号区域为可能发生异常的代码，称为监控区。当抛出异常或者出现运行时异常，然后由 Java 运行时系统巡展匹配 catch 子句。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。

匹配规则：抛出的异常属于 catch 语句捕获异常类及子类，则匹配成功。

需要注意的是：**一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会，并且 try 里面如果有没有走完的语句也会自动跳过**。

*  try-catch-finally

这个很简单，无论 try-catch 是正常结束还是发生异常捕获，都会执行 finally 语句，如果在 finally 之前发生了 return，那么 finally 语句块会在 retrun 之前执行。

**小结：**

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。  
catch 块：用于处理try捕获到的异常。  
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。  
finally 如果有 return 会覆盖 catch 里的throw，同样如果 finally 里有 throw 会覆盖 catch 里的 return。

try-catch-finally 规则

1.必须在 try 后面添加 catch 或 finally。可以同时存在，catch 块也可以有多个，但是 catch 必须放在 try 块或者 catch 块后面。  
2.try-catch-finally 可以嵌套  
3.在 try-catch-finally 结构中，可以重新抛出异常  
4.除非 finally 中抛出异常或者 JVM 停止运行，否则都会执行 finally 语句

try-catch-finally 语句执行顺序  
1.当 try 没有捕获到异常时：try 语句正常执行，程序跳过 catch 语句，执行 finally。

2.当 try 捕获到异常时，catch 没有匹配上异常，则交个 JVM 处理，finally 语句块还是会被执行，但是 finally 之后的语句不会被执行了。

3.当 try 捕获到异常，catch 匹配上了，则按照 try-catch-finally 的正常顺序执行，但是 try 里面异常语句之后的语句不会被执行。

### 抛出异常 ###

任何 Java 代码都可以抛出异常，语句通过 throw 抛出、方法则是 throws。

为什么要 throw 异常？

如果一个方法可能会出现异常，但是没有能力处理这种又一次，则可以在方法声明处用 throws 语句来抛出。

throws 语句可以同时声明抛出多个异常，语法格式如下

void methodName()throws Exception1,Exception2,Exception3{
    }复制代码

就酱紫。此时这个方法就不用对方法重点问这些异常做任何处理，但是调用这个方法的语句必须要处理，要么继续抛，要么 try-catch。

Throws 抛出规则

1.如果是不可查异常，那么不用声明，编译仍然可以通过，但是运行时会被JVM 抛出  
2.如果是可查异常，要么 try-catch，要么 throws，否则编译无法通过。  
3.当抛出了异常时，该方法的调用者才会处理或者重新抛出该异常。  
4.调用 throws 异常的方法，必须 try-catch 调用语气，且 catch 的异常必须是抛出异常的同类或者父类。

Throw 抛出异常  
这个真没什么好说的了，想抛或者需要抛，就直接调用就行了，注意 throw 后面只能接 Throwable 的子类。

# Throwable 类常用方法 #

这个本应该在开篇就讲的，但是好像都不怎么常用，所以就放在这里查漏补缺吧

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>方法说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Throwable</td> 
   <td>fillInStackTrace()</td> 
   <td>在异常堆栈跟踪中填充</td> 
  </tr> 
  <tr> 
   <td>Throwable</td> 
   <td>getCause</td> 
   <td>返回 Throwable 的 cause</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>getLocalizedMessage</td> 
   <td>创建此 Throwable 的本地化描述</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>getMessage</td> 
   <td>返回此 Throwable 的详细消息字符串</td> 
  </tr> 
  <tr> 
   <td>StackTraceElement[]</td> 
   <td>getStackTrace()</td> 
   <td>提供编程访问由printStackTrace 输出的堆栈跟踪信息</td> 
  </tr> 
  <tr> 
   <td>Throwable</td> 
   <td>initCause</td> 
   <td>将此 throwable 的 cause 初始化为指定值</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>printStackTrace</td> 
   <td>将此 Throwable 及其追踪输出至标准错物流</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>toString</td> 
   <td>返回此 Throwable 的简短描述</td> 
  </tr> 
 </tbody> 
</table>

# Java 常见的异常 #

*  运行时异常  
    1.ArrayIndexOutOfBoundException  
    数组索引越界异常。  
    2.ArithmeticException  
    算术条件异常，如除数为0  
    3.NullPointException  
    空指针异常。  
    4.ClassNotFoundException  
    找不到类异常。  
    5.NegativeArraySizeException  
    数组长度为负异常  
    6.ArrayStoreException  
    数组中包含不兼容的值抛出异常  
    7.SecurityException  
    安全性异常  
    8.IllegalArgumentException  
    非法参数异常
 *  IOException  
    1.IOException  
    操作输入流和输出流可能出现的异常  
    2.EOFException  
    文件已结束异常  
    3.FileNotFoundException  
    文件未找到异常

*  其他  
    1.ClassCastException  
    类型转换异常类  
    2.ArrayStoreException  
    数组中包含不兼容的值抛出的异常  
    3.SQLException  
    操作数据库异常类  
    4.NoSuchFieldException  
    字段未找到异常  
    5.NoSuchMethodException  
    方法未找到抛出的异常  
    6.NumberFormatException  
    字符串转换为数字抛出的异常  
    7.StringIndexOutOfBoundsException  
    字符串索引超出范围抛出的异常  
    8.IllegalAccessException  
    不允许访问某类异常  
    9.InstantiationException  
    当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常

# 自定义异常 #

使用Java 内置的异常类可以描述在编程中出现的大部分情况，除此之外，用户还可以自定义异常。自定义异常类，只需要继承 Exception 即可。在程序中使用自定义异常类，大体可分为以下几个步骤。

1.创建自定义异常类。  
2.在方法中通过throw关键字抛出异常对象。  
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。  
4.在出现异常方法的调用者中捕获并处理异常。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70]: /images/20221023/ab9d7515f8de4f70b5936ba96e638e6e.png