Java中的异常Exception和捕获，自定义异常

蔚落 2023-09-26 20:32 146阅读 0赞

![在这里插入图片描述][cf73fcffd76c487d84b663f687e317d7.gif_pic_center]

#### 文章目录 ####

*   *  1. 异常概述
     *   *  1.1 什么是程序的异常
         *  1.2 异常的抛出机制
         *  1.3 如何对待异常
     *  2. Java异常体系
     *   *  2.1 Throwable
         *  2.2 Error 和 Exception
         *  2.3 编译时异常和运行时异常
     *  3. 常见的错误和异常
     *   *  3.1 Error
         *  3.2 运行时异常
         *  3.3 编译时异常
     *  4. 异常的处理
     *   *  4.1 异常处理概述
         *  4.2 捕获异常（try-catch-finally）
         *   *  4.2.1 try-catch-finally基本格式
             *  4.2.2 finally使用及举例
         *  4.3 声明抛出异常类型（throws）
         *   *  4.3.1 throws基本格式
             *  4.3.2 方法重写中throws的要求
         *  4.4 两种异常处理方式的选择
     *  5. 手动抛出异常对象：throw
     *   *  5.1 使用格式
         *  5.2 使用注意点
     *  6. 自定义异常
     *   *  6.1 为什么需要自定义异常类
         *  6.2 如何自定义异常类
         *  6.3 注意点
     *  7. 总结

### 1. 异常概述 ###

#### 1.1 什么是程序的异常 ####

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的。

异常 ：指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致JVM的非正常停止。

异常指的并不是语法错误和逻辑错误。语法错了，编译不通过，不会产生字节码文件，根本不能运行。代码逻辑错误，只是没有得到想要的结果，例如：求a与b的和，你写成了a-b。

#### 1.2 异常的抛出机制 ####

Java中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型的对象，并且抛出（`throw`）。然后程序员可以捕获(`catch`)到这个异常对象，并处理；如果没有捕获(catch)这个异常对象，那么这个异常对象将会导致程序终止。

**模拟程序会产生一个数组角标越界异常（ArrayIndexOfBoundsException）：**

public class ArrayTools {
        
        // 对给定的数组通过给定的角标获取元素。
        public static int getElement(int[] arr, int index) {
        
            int element = arr[index];
            return element;
        }
    }
    
    //测试类
    public class ExceptionDemo {
        
        public static void main(String[] args) {
        
            int[] arr = {
         34, 12, 67 };
            intnum = ArrayTools.getElement(arr, 4)
            System.out.println("num=" + num);
            System.out.println("over");
        }
    }

**上述程序执行过程图解：**

![在这里插入图片描述][6759888b3e294c9fbc894b5ea573e6b4.png_pic_center]

#### 1.3 如何对待异常 ####

对于程序出现的异常，一般有两种解决方法：一是遇到错误就终止程序的运行。另一种方法是程序员在编写程序时，就充分考虑到各种可能发生的异常和错误，极力预防和避免。实在无法避免的，要编写相应的代码进行异常的检测、以及异常的处理，保证代码的健壮性。

### 2. Java异常体系 ###

#### 2.1 Throwable ####

**Throwable中的常用方法：**

*  public void printStackTrace()：打印异常的详细信息。

包含了异常的类型、异常的原因、异常出现的位置、在开发和调试阶段都得使用`printStackTrace`。

*  public String getMessage()：获取发生异常的原因。

#### 2.2 Error 和 Exception ####

`Throwable`可分为两类：`Error`和`Exception`。分别对应着`java.lang.Error`与`java.lang.Exception`两个类。

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

*  例如：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存溢出，简称OOM）。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。

*  空指针访问
 *  试图读取不存在的文件
 *  网络连接中断
 *  数组角标越界
 *  …

**说明：**

*  无论是Error还是Exception，还有很多子类，异常的类型非常丰富。当代码运行出现异常时，特别是我们不熟悉的异常时，不要紧张，把异常的类名，找到对应API中去了解是什么类型的异常。

#### 2.3 编译时异常和运行时异常 ####

Java程序的执行分为编译时过程和运行时过程。有的错误只有在运行时才会发生。

![在这里插入图片描述][4469520ac2d14aa195f6fbeb0d8c092c.png_pic_center]

**根据异常可能出现的阶段，可以将异常分为：**

*  **编译时期异常**（即checked异常、受检异常）：在代码编译阶段，编译器就能明确警示当前代码可能发生（不是一定发生）xx异常，并明确督促程序员提前编写处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判定编译失败，从而不能生成字节码文件。通常，这类异常的发生不是由程序员的代码引起的，或者不是靠加简单判断就可以避免的，例如：FileNotFoundException（文件找不到异常）。
 *  **运行时期异常**（即runtime异常、unchecked异常、非受检异常）：在代码编译阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何提示。只有等代码运行起来并确实发生了xx异常，它才能被发现。通常，这类异常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免。
    
     *  `java.lang.RuntimeException`:类及它的子类都是运行时异常。比如：`ArrayIndexOutOfBoundsException`:数组下标越界异常，`ClassCastException`类型转换异常。

![在这里插入图片描述][d8f6d630df174e12bdd6ccffae17e60a.png_pic_center]

### 3. 常见的错误和异常 ###

#### 3.1 Error ####

最常见的就是`VirtualMachineError`，它有两个经典的子类：`StackOverflowError`、`OutOfMemoryError`。

@Test
    public void test01(){
        
        //StackOverflowError
        recursion();
    }
    
    public void recursion(){
         //递归方法
        recursion(); 
    }

@Test
    public void test02(){
        
        //OutOfMemoryError
        //方式一：
        int[] arr = new int[Integer.MAX_VALUE];
    }

#### 3.2 运行时异常 ####

@Test
    public void test05(){
        
        int a = 1;
        int b = 0;
        //ArithmeticException
        System.out.println(a/b);
    }

#### 3.3 编译时异常 ####

@Test
    public void test06() {
        
        Thread.sleep(1000);//休眠1秒  InterruptedException
    }

### 4. 异常的处理 ###

#### 4.1 异常处理概述 ####

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的if-else分支会导致程序的代码加长、臃肿，可读性差，程序员需要花很大的精力“堵漏洞”。因此采用异常处理机制。

**Java异常处理:**

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

**Java异常处理的方式：**

**方式一：** try-catch-finally  
**方式二：** throws + 异常类型

#### 4.2 捕获异常（try-catch-finally） ####

Java提供了异常处理的抓抛模型。

*  Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(`throw`)异常。
 *  如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(`catch`)异常。
 *  如果一个异常回到`main()`方法，并且main()也不处理，则程序运行终止。

##### 4.2.1 try-catch-finally基本格式 #####

try{
        
    	......	//可能产生异常的代码
    }
    catch( 异常类型1 e ){
        
    	......	//当产生异常类型1型异常时的处置措施
    }
    catch( 异常类型2 e ){
        
    	...... 	//当产生异常类型2型异常时的处置措施
    }  
    finally{
        
    	...... //无论是否发生异常，都无条件执行的语句
    }

**1、整体执行过程：**

当某段代码可能发生异常，不管这个异常是编译时异常（受检异常）还是运行时异常（非受检异常），我们都可以使用try块将它括起来，并在`try`块下面编写`catch`分支尝试捕获对应的异常对象。

*  如果在程序运行时，try块中的代码没有发生异常，那么catch所有的分支都不执行。
 *  如果在程序运行时，try块中的代码发生了异常，根据异常对象的类型，将从上到下选择第一个匹配的catch分支执行。此时try中发生异常的语句下面的代码将不执行，而整个try…catch之后的代码可以继续运行。
 *  如果在程序运行时，try块中的代码发生了异常，但是所有catch分支都无法匹配（捕获）这个异常，那么JVM将会终止当前方法的执行，并把异常对象“抛”给调用者。如果调用者不处理，程序就挂了。

![在这里插入图片描述][e7c90cb632954e90aae251462730d49f.png_pic_center]

**2、try：**

捕获异常的第一步是用`try{…}`语句块选定捕获异常的范围，将可能出现异常的业务逻辑代码放在try语句块中。

**3、catch (Exceptiontype e)**

*  `catch`分支，分为两个部分，`catch()`中编写异常类型和异常参数名，`{}`中编写如果发生了这个异常，要做什么处理的代码。
 *  如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。  
    比如：可以用`ArithmeticException`类作为参数的地方，就可以用`RuntimeException`类作为参数，或者用所有异常的父类`Exception`类作为参数。但不能是与`ArithmeticException`类无关的异常，如`NullPointerException`（catch中的语句将不会执行）。
 *  每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
 *  如果有多个catch分支，并且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。否则，报错。
 *  catch中常用异常处理的方式
    
     *  `public String getMessage()`：获取异常的描述信息，返回字符串
     *  `public void printStackTrace()`：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型、异常的原因、还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace()。

![在这里插入图片描述][4ca2e88285d84a039674f53f7b3f75aa.png_pic_center]

##### 4.2.2 finally使用及举例 #####

![在这里插入图片描述][e9e78ddb0adf4e2c9cb448cc663a604a.png_pic_center]

*  因为异常会引发程序跳转，从而会导致有些语句执行不到。而程序中有一些特定的代码无论异常是否发生，都需要执行。例如，数据库连接、输入流输出流、Socket连接、Lock锁的关闭等，这样的代码通常就会放到finally块中。所以，我们通常将一定要被执行的代码声明在finally中。
    
     *  唯一的例外，使用 System.exit(0) 来终止当前正在运行的 Java 虚拟机。
 *  不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
 *  finally语句和catch语句是可选的，但finally不能单独使用。

#### 4.3 声明抛出异常类型（throws） ####

如果在编写方法体的代码时，某句代码可能发生某个编译时异常，不处理编译不通过，但是在当前方法体中可能不适合处理或无法给出合理的处理方式，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

![在这里插入图片描述][ff85d41873cf4ac79b45bcc8e97c2b4a.png_pic_center]

**具体方式：** 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

##### 4.3.1 throws基本格式 #####

**声明异常格式：**

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…\{ \}  
在throws后面可以写多个异常类型，用逗号隔开。

public void readFile(String file)  throws FileNotFoundException,IOException {
        
    	...
    	// 读文件的操作可能产生FileNotFoundException或IOException类型的异常
    	FileInputStream fis = new FileInputStream(file);
        //...
    }

`throws`后面也可以写运行时异常类型，只是运行时异常类型，写或不写对于编译器和程序执行来说都没有任何区别。如果写了，唯一的区别就是调用者调用该方法后，使用try…catch结构时，IDEA可以获得更多的信息，需要添加哪种`catch`分支。

##### 4.3.2 方法重写中throws的要求 #####

**方法重写时：**

（1）方法名必须相同  
（2）形参列表必须相同  
（3）返回值类型

*  基本数据类型和`void`：必须相同
 *  引用数据类型：<=

（4）权限修饰符：>=，而且要求父类被重写方法在子类中是可见的  
（5）不能是`static`，`final`修饰的方法

**对于throws异常列表要求：**

*  如果父类被重写方法的方法签名后面没有 “throws 编译时异常类型”，那么重写方法时，方法签名后面也不能出现“throws 编译时异常类型”。
 *  如果父类被重写方法的方法签名后面有 “throws 编译时异常类型”，那么重写方法时，throws的编译时异常类型必须 <= 被重写方法throws的编译时异常类型，或者不throws编译时异常。
 *  方法重写，对于“throws 运行时异常类型”没有要求。

#### 4.4 两种异常处理方式的选择 ####

对于异常，使用相应的处理方式。此时的异常，主要指的是编译时异常

*  如果程序代码中，涉及到资源的调用（流、数据库连接、网络连接等），则必须考虑使用`try-catch-finally`来处理，保证不出现内存泄漏。
 *  如果父类被重写的方法没有`throws`异常类型，则子类重写的方法中如果出现异常，只能考虑使用`try-catch-finally`进行处理，不能`throws`。
 *  开发中，方法a中依次调用了方法b,c,d等方法，方法b,c,d之间是递进关系。此时，如果方法b,c,d中有异常，我们通常选择使用throws，而方法a中通常选择使用try-catch-finally。

### 5. 手动抛出异常对象：throw ###

**Java 中异常对象的生成有两种方式：**

*  由虚拟机**自动生成**：程序运行过程中，虚拟机检测到程序发生了问题，那么针对当前代码，就会在后台自动创建一个对应异常类的实例对象并抛出。
 *  由开发人员**手动创建**：new 异常类型(\[实参列表\]);，如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但是一旦throw抛出，就会对程序运行产生影响了。

#### 5.1 使用格式 ####

throw new 异常类名(参数);

throw语句抛出的异常对象，和JVM自动创建和抛出的异常对象一样。

*  如果是编译时异常类型的对象，同样需要使用throws或者try…catch处理，否则编译不通过。
 *  如果是运行时异常类型的对象，编译器不提示。
 *  可以抛出的异常必须是`Throwable`或其子类的实例。

#### 5.2 使用注意点 ####

无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被`try..catch`合理的处理，都会导致程序崩溃。

throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行。

如果当前方法没有try…catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者。

### 6. 自定义异常 ###

#### 6.1 为什么需要自定义异常类 ####

Java中不同的异常类，分别表示着某一种具体的异常情况。那么在开发中总是有些异常情况是核心类库中没有定义好的，此时我们需要根据自己业务的异常情况来定义和业务相关的异常类。

#### 6.2 如何自定义异常类 ####

**（1）要继承一个异常类型**

自定义一个编译时异常类型：自定义类继承java.lang.Exception。  
自定义一个运行时异常类型：自定义类继承java.lang.RuntimeException。

**（2）建议提供至少两个构造器，一个是无参构造，一个是(String message)构造器。**

**（3）自定义异常需要提供serialVersionUID**

#### 6.3 注意点 ####

1.  自定义的异常只能通过throw抛出。
2.  自定义异常最重要的是异常类的名字和message属性。当异常出现时，可以根据名字判断异常类型。比如：TeamException(“成员已满，无法添加”);
3.  自定义异常对象只能手动抛出。抛出后由try…catch处理，也可以甩锅throws给调用者处理。

**示例：**

//自定义异常：
    public class NotTriangleException extends Exception{
        
        static final long serialVersionUID = 13465653435L;
    
        public NotTriangleException() {
        
        }
    
        public NotTriangleException(String message) {
        
            super(message);
        }
    }
    //手动抛出异常对象
    throw new NotTriangleException("输入数据不正确");

### 7. 总结 ###

异常处理5个关键字：

![在这里插入图片描述][e3c58329d787418b923de7ef1f24d56f.png_pic_center]

世界上最遥远的距离，是我在if里你在else里，似乎一直相伴又永远分离；  
世界上最痴心的等待，是我当case你是switch，或许永远都选不上自己；  
世界上最真情的相依，是你在try我在catch。无论你发神马脾气，我都默默承受，静静处理。到那时，再来期待我们的finally。

[cf73fcffd76c487d84b663f687e317d7.gif_pic_center]: https://img-blog.csdnimg.cn/cf73fcffd76c487d84b663f687e317d7.gif#pic_center
[6759888b3e294c9fbc894b5ea573e6b4.png_pic_center]: https://img-blog.csdnimg.cn/6759888b3e294c9fbc894b5ea573e6b4.png#pic_center
[4469520ac2d14aa195f6fbeb0d8c092c.png_pic_center]: https://img-blog.csdnimg.cn/4469520ac2d14aa195f6fbeb0d8c092c.png#pic_center
[d8f6d630df174e12bdd6ccffae17e60a.png_pic_center]: https://img-blog.csdnimg.cn/d8f6d630df174e12bdd6ccffae17e60a.png#pic_center
[e7c90cb632954e90aae251462730d49f.png_pic_center]: https://img-blog.csdnimg.cn/e7c90cb632954e90aae251462730d49f.png#pic_center
[4ca2e88285d84a039674f53f7b3f75aa.png_pic_center]: https://img-blog.csdnimg.cn/4ca2e88285d84a039674f53f7b3f75aa.png#pic_center
[e9e78ddb0adf4e2c9cb448cc663a604a.png_pic_center]: https://img-blog.csdnimg.cn/e9e78ddb0adf4e2c9cb448cc663a604a.png#pic_center
[ff85d41873cf4ac79b45bcc8e97c2b4a.png_pic_center]: https://img-blog.csdnimg.cn/ff85d41873cf4ac79b45bcc8e97c2b4a.png#pic_center
[e3c58329d787418b923de7ef1f24d56f.png_pic_center]: https://img-blog.csdnimg.cn/e3c58329d787418b923de7ef1f24d56f.png#pic_center