异常的捕获与处理

ゞ浴缸里的玫瑰 2024-04-03 10:03 73阅读 0赞

## 前言： ##

*  大部分学自狂神说和课本的一些内容，仅供学习和参考，无任何商业行为。
 *  笔者水平有限，错漏之处在所难免，还请朋友们批评指正。  
    
    
    #### 文章目录 ####
    
     *  前言：
     *  异常概念
     *  异常类型
     *   *  系统错误--Error类
         *  可控式异常--Exception类
         *  Error 和 Exception 的区别
         *  运行时异常--RunTimeException类
         *  其他的分类说法
     *  Java异常处理机制
     *   *  抛出异常
         *  捕获异常
         *  异常处理关键字
         *  处理异常
         *   *  try -catch 代码块
         *  throws
         *  finally
         *  try, catch,finally ,return 执行顺序
         *  自定义异常
     *  总结概览图

## 异常概念 ##

*  异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
 *  异常发生在程序运行期间,它影响了正常的程序执行流程。
 *  在java语言中，异常是对象，表示组织程序正常运行的错误。换言之，程序在运行的过程中，如果java虚拟机检测到一个不能执行的操作，程序就会终止运行，同时抛出异常。
 *  Java异常是一个描述在代码段中发生异常的对象，当发生异常情况时，一个代表该异常的对象被创  
    建并且在导致该异常的方法中被抛出，而该方法可以选择自己处理异常或者传递该异常。

## 异常类型 ##

![在这里插入图片描述][473dbae771484f7f96782a5e0866221e.png]

*  **Throwable 分成了两个不同的分支，一个分支是Error，它表示不希望被程序捕获或者是程序无法处理的错误。另一个分支是Exception，它表示用户程序可能捕捉的异常情况或者说是程序可以处理的异常**。
 *  异常是对象，由异常类来定义。所有的异常类都直接或间接地继承java.lang包中的Throwable类。
 *  Throwable类主要包含3类异常：***系统错误、可控式异常、运行时异常***。
 *  **可控式异常【Exception】**：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如：要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
 *  **运行时异常【RunTimeException】**： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
 *  **系统错误【错误/error】**： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

### 系统错误–Error类 ###

*  ***不应该试图捕获的严重问题***。
 *  ***对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况***。在Java中，错误通常是使用 Error 的子类描述。
 *  Error 类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。例如：当JVM不再有继续执行操作所需的内存资源时，将出现 ***OutOfMemoryError*** 。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；还有发生在虚拟机试图执行应用时，如***类定义错误（ NoClassDefFoundError ）、链接错误（ LinkageError ）***。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。

<table> 
 <thead> 
  <tr> 
   <th>错误栗子</th> 
   <th>解决方案</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字节码文件无法解析</td> 
   <td>重新编写程序</td> 
  </tr> 
  <tr> 
   <td>java虚拟机资源耗尽</td> 
   <td>重新分配系统资源</td> 
  </tr> 
  <tr> 
   <td>配置文件格式不规范</td> 
   <td>进行修正</td> 
  </tr> 
 </tbody> 
</table>

### 可控式异常–Exception类 ###

*  这里异常能够被捕获并处理。
 *  在 Exception 分支中有一个重要的子类 ***RuntimeException （运行时异常）***，该类型的异常自动为你所编写的程序定义 \*\*\*ArrayIndexOutOfBoundsException （数组下标越界）、NullPointerException （空指针异常）、ArithmeticException （算术异常）、 MissingResourceException （丢失资源）、ClassNotFoundException （找不到类）\*\*\*等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

> 提示：不要觉得很害怕，在大量的实际编程中，你会经常见到它们。同时，简单的留个印象，还可以在你遇见这些报错时，快速解决错误。

*  这些异常一般是由程序逻辑错误引起的，**程序应该从逻辑角度尽可能避免这类异常的发生**；而***RuntimeException 之外的异常我们统称为非运行时异常，类型上属于 Exception 类及其子类。***
 *  从程序语法角度讲是**必须进行处理的异常，如果不处理，程序就不能编译通过**。如IOException 、 SQLException 等以及用户自定义的 Exception 异常，一般情况下不自定义检查异常。

### Error 和 Exception 的区别 ###

*  Error 通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程
 *  Exception 通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

### 运行时异常–RunTimeException类 ###

*  运行时异常指的是程序的设计错误。
 *  常见的RunTimeException类的子类

<table> 
 <thead> 
  <tr> 
   <th>子类</th> 
   <th>可能引起运行错误的原因</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>IndexOutOfBoundsException</td> 
   <td>抛出以表示某种索引（例如数组，字符串或向量）的索引超出范围。</td> 
  </tr> 
  <tr> 
   <td>NullPointerException</td> 
   <td>当应用 null在需要对象的情况下尝试使用 null时抛出。</td> 
  </tr> 
  <tr> 
   <td>ArithmeticException</td> 
   <td>抛出异常算术条件时抛出。</td> 
  </tr> 
  <tr> 
   <td>IllegalArgumentException</td> 
   <td>抛出表示一种方法已经通过了非法或不正确的参数。</td> 
  </tr> 
 </tbody> 
</table>

### 其他的分类说法 ###

*  检查异常和不受检查异常
 *  检查异常：在正确的程序运行过程中，很容易出现的、情理可容的异常状况，在一定程度上这种异常的发生是可以预测的，并且一旦发生该种异常，就必须采取某种方式进行处理。

> 解析：除了RuntimeException及其子类以外，其他的Exception类及其子类都属于检查异常，当程序中可能出现这类异常，要么使用try-catch语句进行捕获，要么用throws子句抛出，否则编译无法通过。

*  不受检查异常：包括RuntimeException及其子类和Error。

> 分析： 不受检查异常 为编译器不要求强制处理的异常， 检查异常 则是编译器要求必须处置的异常。

## Java异常处理机制 ##

*  **java异常处理本质：抛出异常和捕获异常**

### 抛出异常 ###

*  异常情形（exception condition），它是指阻止当前方法或作用域继续执行的问题。其次把异常情形和普通问题相区分，普通问题是指在当前环境下能得到足够的信息，总能处理这个错误。
 *  对于异常情形，已经无法继续下去了，因为在当前环境下无法获得必要的信息来解决问题，你所能做的就是从当前环境中跳出，并把问题提交给上一级环境，这就是抛出异常时所发生的事情。抛出异常后，会有几件事随之发生。
 *  使用步骤：
    
     *  ***首先，是像创建普通的java对象一样将使用 new 在堆上创建一个异常对象***；然后，当前的执行路径（已经无法继续下去了）被终止，并且从当前环境中弹出对异常对象的引用。此时，异常处理机制接管程序，并开始寻找一个恰当的地方继续执行程序，这个恰当的地方就是异常处理程序或者异常处理器，它的任务是将程序从错误状态中恢复，以使程序要么换一种方式运行，要么继续运行下去。

### 捕获异常 ###

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

> 注意：
> 
>  *  对于***运行时异常 、 错误和检查异常*** ，Java技术所要求的异常处理方式有所不同。  
>     \- 由于运行时异常及其子类的不可查性，为了更合理、更容易地实现应用程序，Java规定，***运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常***。  
>     \- 对于方法运行中可能出现的 Error ，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数 Error 异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。  
>     \- 对于所有的检查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉检查异常时，它必须声明将抛出异常。

### 异常处理关键字 ###

<table> 
 <thead> 
  <tr> 
   <th>异常处理关键字</th> 
   <th>详解</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>try</td> 
   <td>用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。</td> 
  </tr> 
  <tr> 
   <td>catch</td> 
   <td>用于捕获异常。catch用来捕获try语句块中发生的异常。</td> 
  </tr> 
  <tr> 
   <td>finally</td> 
   <td>finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。</td> 
  </tr> 
  <tr> 
   <td>throw</td> 
   <td>用于抛出异常。</td> 
  </tr> 
  <tr> 
   <td>throws</td> 
   <td>用在方法签名中，用于声明该方法可能抛出的异常。</td> 
  </tr> 
 </tbody> 
</table>

### 处理异常 ###

#### try -catch 代码块 ####

//监控区域
    try{
        
    //code that might generate exceptions
    }catch(Exception e){
        
    //the code of handling exception1
    }catch(Exception e){
        
    //the code of handling exception2
    }

> 监控区域 （guarded region）的概念。它是一段可能产生异常的代码，并且后面跟着处理这些异常的代码。

*  catch 子句来捕获异常，若有一个catch 语句匹配到了相应的异常，则执行该 catch 块中的异常处理代码，就不再尝试匹配别的 catch 块了。
 *  ***匹配原则：如果抛出的异常对象属于 catch 子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与 catch 块捕获的异常类型相匹配。***

public class TestException {
        
    public static void main(String[] args) {
        
    	int a = 1;
    	int b = 0;
    	try {
         // try监控区域
    		if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常
    		System.out.println("a/b的值是：" + a / b);
    		System.out.println("this will not be printed!");
    	}
    	catch (ArithmeticException e) {
         // catch捕捉异常
    		System.out.println("程序出现异常，变量b不能为0！");
    	}
    	System.out.println("程序正常结束。");
    	}
    }
    //输出
    程序出现异常，变量b不能为0！
    程序正常结束。

> 注意点：  
> \- 编写多重catch语句块注意事项：顺序:先小后大，即先子类后父类  
> java通过异常类描述异常类型。对于有多个 catch 子句的异常程序而言，应该尽量将捕获底层异常类的 catch 子句放在前面，同时尽量将捕获相对高层的异常类的 catch 子句放在后面。否则，捕获底层异常类的 catch 子句将可能会被屏蔽。  
> \- 嵌套try语句： try 语句可以被嵌套。也就是说，一个 try 语句可以在另一个 try 块的内部。每次进入 try 语句，异常的前后关系都会被推入堆栈。如果一个内部的 try 语句不含特殊异常的catch 处理程序，堆栈将弹出，下一个 try 语句的 catch 处理程序将检查是否与之匹配。这个过程将继续直到一个 catch 语句被匹配成功，或者是直到所有的嵌套 try 语句被检查完毕。如果没有 catch 语句匹配，Java运行时系统将处理这个异常。

### throws ###

*  如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常。要做到这点，我们可以在方法声明中包含一个 throws 子句。
 *  一个 throws 子句列举了一个方法可能引发的所有异常类型。这对于除了 Error 或RuntimeException 及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他类型的异常必须在 throws 子句中声明，否则会导致编译错误。

// Exception 是该方法可能引发的所有的异常,也可以是异常列表，中间以逗号隔开。
    ublic void info() throws ExceptionA,ExceptionB
    {
        
    	//body of method
    }

*  栗子

class TestThrows{
        
    	static void throw1() throws IllegalAccessException {
        
    		System.out.println("Inside throw1 . ");
    		throw new IllegalAccessException("demo");
    	}
    	
    	public static void main(String[] args){
        
    		try {
        
    			throw1();
    		}
    		catch(IllegalAccessException e ){
        
    		System.out.println("Caught " + e);
    		}
    	}
    }

*  throws 抛出异常的规则：
    
     *  如果是不受检查异常（ unchecked exception ），即 Error 、 RuntimeException 或它们的子类，那么可以不使用 throws 关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
     *  必须声明方法可抛出的任何检查异常（ checked exception ）。即如果一个方法可能出现受可查异常，要么用 try-catch 语句捕获，要么用 throws 子句声明将它抛出，否则会导致编译错误。
     *  仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
     *  调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

### finally ###

*  ***当异常发生时，通常方法的执行将做一个陡峭的非线性的转向，它甚至会过早的导致方法返回。例如，如果一个方法打开了一个文件并关闭，然后退出，你不希望关闭文件的代码被异常处理机制旁路。finally 关键字为处理这种意外而设计。***
 *  finally 创建的代码块在 try/catch 块完成之后另一个 try/catch 出现之前执行。finally 块无论有没有异常抛出都会执行。如果抛出异常，即使没有 catch 子句匹配，finally 也会执行。
 *  ***finally 子句是可选项，可以有也可以无，但是每个 try 语句至少需要一个 catch 或者 finally 子句。***

### try, catch,finally ,return 执行顺序 ###

1．执行try，catch ， 给返回值赋值  
2．执行finally  
3．return

### 自定义异常 ###

*  使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承 Exception 类即可。
 *  在程序中使用自定义异常类，大体可分为以下几个步骤:
    
    1.  创建自定义异常类。
    2.  在方法中通过 throw 关键字抛出异常对象。
    3.  如果在当前抛出异常的方法中处理异常，可以使用 try-catch 语句捕获并处理；否则在方法的
    4.  声明处通过 throws 关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
    5.  在出现异常方法的调用者中捕获并处理异常。
 *  栗子

class MyException extends Exception {
        
    	private int detail;
    	MyException(int a){
        
    	detail = a;
    	}
    	public String toString(){
        
    		return "MyException ["+ detail + "]";
    		}
    }
    
    public class TestMyException{
        
    	static void compute(int a) throws MyException{
        
    		System.out.println("Called compute(" + a + ")");
    		if(a > 10){
        
    			throw new MyException(a);
    		}
    	System.out.println("Normal exit!");
    }
    public static void main(String [] args){
        
    		try{
        
    			compute(1);
    			compute(20);
    		}catch(MyException me){
        
    			System.out.println("Caught " + me);
    		}
    	}
    }

Called compute(1)
    Normal exit!
    Called compute(20)
    Caught MyException [20]

## 总结概览图 ##

![在这里插入图片描述][87cfee498fcf498fbe2cf0931a4f6595.png]

[473dbae771484f7f96782a5e0866221e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/28f80e3fe2f44a11b7f9ecdd2f4be38b.png
[87cfee498fcf498fbe2cf0931a4f6595.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/a01f3fe59a3b4b2c8feb63d84d0a12df.png