javaSE - 异常（Exception 或 RuntimeException）

迈不过友情╰ 2023-10-08 17:21 50阅读 0赞

## 一、异常的背景 ##

### 1.1、初识异常 ###

> 其实在我们开发中，就是代码出现意外状况。影响到程序的运行。  
> 其实，在我们接触代码开始，就一直在接触异常，只是从来没有分类。  
> 这点在java中，更加明显。  
> 现在我们就来基本了解一下异常。

#### 算数异常 ArithmeticException ####

public static void main(String[] args) {
        
            int a = 10;
            System.out.println(a / 0);
        }

![在这里插入图片描述][4194e09d73aa4d15beb0da8a238d1b6f.png]

#### 数组越界异常 ArrayIndexOutOfBoundsException ####

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            for (int i = 0; i < 10; i++) {
        
                System.out.println(array[i]);
            }
        }

![在这里插入图片描述][3c78afc18c414fbd90d93cd40f69624c.png]

#### 空指针异常 NullPointerException ####

public static void main(String[] args) {
        
            String str = null;
            System.out.println(str.length());
        }

![在这里插入图片描述][64ed783637c644cc833acf1b7f599a51.png]

**所谓异常指的就是程序在 运行时 出现错误时通知调用者的一种机制**

> 关键字 “运行时”  
> 有些错误是这样的, 例如将 System.out.println 拼写错了, 写成了 system.out.println. 此时编译过程中就会出错, 这是 “编译期” 出错.  
> 而运行时指的是程序已经编译通过得到 class 文件了, 再由 JVM 执行过程中出现的错误

异常的种类有很多, 不同种类的异常具有不同的含义, 也有不同的处理方式

### 1.2、防御式编程 ###

错误在代码中是客观存在的. 因此我们要让程序出现问题的时候及时通知程序猿. 我们有两种主要的方式

*  LBYL: Look Before You Leap. 在操作之前就做充分的检查.
 *  EAFP: It’s Easier to Ask Forgiveness than Permission. “事后获取原谅比事前获取许可更容易”. 也就是先操作, 遇到  
    问题再处理

异常的核心思想就是 EAFP

### 1.3、异常的好处 ###

下面，我们用伪代码演示一下开始一局王者荣耀的过程

#### LBYL 风格的代码(不使用异常) ####

boolean ret = false;
    ret = 登陆游戏();
    if (!ret) {
        
    	处理登陆游戏错误;
    	return;
    }
    ret = 开始匹配();
    if (!ret) {
        
    	处理匹配错误;
    	return;
    }
    ret = 游戏确认();
    if (!ret) {
        
    	处理游戏确认错误;
    	return;
    }
    ret = 选择英雄();
    if (!ret) {
        
    	处理选择英雄错误;
    	return;
    }
    ret = 载入游戏画面();
    if (!ret) {
        
    	处理载入游戏错误;
    	return;
    }

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

#### EAFP 风格的代码(使用异常) ####

try {
        
    登陆游戏();
    开始匹配();
    游戏确认();
    选择英雄();
    载入游戏画面();
    ...
    } catch (登陆游戏异常) {
        
    	处理登陆游戏异常;
    } catch (开始匹配异常) {
        
    	处理开始匹配异常;
    } catch (游戏确认异常) {
        
    	处理游戏确认异常;
    } catch (选择英雄异常) {
        
    	处理选择英雄异常;
    } catch (载入游戏画面异常) {
        
    	处理载入游戏画面异常;
    }
    ......

![在这里插入图片描述][cac20d41245a4ce598d64a45e1553323.png]  
**对比两种不同风格的代码, 我们可以发现, 使用第一种方式, 正常流程和错误处理流程代码混在一起, 代码整体显的比较  
混乱. 而第二种方式正常流程和错误流程是分离开的, 更容易理解代码**

## 二、异常的基本用法 ##

### 2.1、基本语法 ###

try{
        
    	有可能出现异常的语句 ;
    }[catch (异常类型 异常对象) {
        
    } ... ]
    [finally {
        
    	异常的出口
    }]

*  try 代码块中放的是可能出现异常的代码.
 *  catch 代码块中放的是出现异常后的处理行为.
 *  finally 代码块中的代码用于处理善后工作, 会在最后执行.
 *  其中 catch 和 finally 都可以根据情况选择加或者不加

### 2.2、使用try-catch处理异常 ###

#### 代码示例1 不处理异常 ####

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            System.out.println(array[10]);
        }

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

#### 代码示例2 处理异常 ####

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                System.out.println(array[10]);
                System.out.println("asddfddf");
            }catch(ArrayIndexOutOfBoundsException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常");
                System.out.println("哈哈");
            }
            System.out.println("代码执行到了这里");
        }

![在这里插入图片描述][071d15d37a9d43debc872d52ab75cb52.png]  
**我们发现，一旦 try 中出现异常，那么 try 代码块中的程序就不会继续执行，而是交给 catch 中的代码来执行，catch 执行完毕会继续往下执行**

> **关于异常的处理方式**
> 
>  *  异常的种类有很多, 我们要根据不同的业务场景来决定.
>  *  对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后果
>  *  对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿
>  *  对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试.
>  *  在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很快 速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息
> 
> **关于 “调用栈”**
> 
>  *  方法之间是存在相互调用关系的， 这种调用关系我们可以用 “调用栈” 来描述，在 JVM 中有一块内存空间称为 “虚拟机栈” 专门存储方法之间的调用关系，当代码中出现异常的时候，我们就可以使用 e.printStackTrace(); 的方式查看出现异常代码的调用栈

**如果我们不处理异常，那这个异常就会交给JVM来处理，那这个程序就会终止  
如果而我们处理了异常，那这个程序机会往下执行**

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                System.out.println(array[10]);
                System.out.println("asddfddf");
            }catch(ArrayIndexOutOfBoundsException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常,然后处理异常");
                for (int i = 0; i < array.length; i++) {
        
                    System.out.print(array[i] + " ");
                }
            }
        }

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

#### 代码示例3 catch 只能处理对应种类的异常 ####

![在这里插入图片描述][9f3a0db4b0c14b798f8dd1866d88956f.png]

#### 代码示例4 catch 可以有多个 ####

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                int a = 10 / 0;
                System.out.println(array[10]);
                System.out.println("hello");
            }catch(ArrayIndexOutOfBoundsException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常,然后处理异常");
                for (int i = 0; i < array.length; i++) {
        
                    System.out.print(array[i] + " ");
                }
            } catch(ArithmeticException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了算数异常，处理异常");
                int a = 10 / 2;
                System.out.println(a);
            }
            System.out.println("哈哈");
        }

**简写上面的代码，捕捉个异常中间可以用“|”连接**

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                int a = 10 / 0;
                System.out.println(array[10]);
                System.out.println("hello");
            }catch(ArrayIndexOutOfBoundsException | ArithmeticException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常或者捕捉到了算数异常,然后处理异常");
                int a = 10;
                System.out.println(a / 2);
                for (int i = 0; i < array.length; i++) {
        
                    System.out.print(array[i] + " ");
                }
            }
            System.out.println("哈哈");
        }

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

### 2.3、异常的体系结构 ###

Java 内置了丰富的异常体系, 用来表示不同情况下的异常.  
下图表示 Java 内置的异常类之间的继承关系:  
![在这里插入图片描述][816cbd65391c49269d1f677700a4155f.png]

*  顶层类 Throwable 派生出两个重要的子类, Error 和 Exception
 *  其中 Error 指的是 Java 运行时内部错误和资源耗尽错误. 应用程序不抛出此类异常. 这种内部错误一旦出现，除了告知用户并使程序终止之外, 再无能无力. 这种情况很少出现.
 *  Exception 是我们程序猿所使用的异常类的父类.
 *  其中 Exception 有一个子类称为 RuntimeException , 这里面又派生出很多我们常见的异常类NullPointerException , IndexOutOfBoundsException 等.

**Java语言规范将派生于 Error 类或 RuntimeException 类的所有异常称为 非受查异常, 所有的其他异常称为 受查  
异常**

#### 2.2.1、异常的分类 ####

异常的分类：

*  1、受查异常（编译时异常），
 *  2、非受查异常（运行时异常）
 *  ![在这里插入图片描述][cb8898e8910f4aeeae3518f1602005b7.png]

### 2.4 finally的使用 ###

#### 代码示例5 也可以用一个 catch 捕获所有异常(不推荐) ####

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                int a = 10 / 0;
                System.out.println(array[10]);
                System.out.println("hello");
            }catch(Exception e){
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常或者捕捉到了算数异常,然后处理异常");
                int a = 10;
                System.out.println(a / 2);
                for (int i = 0; i < array.length; i++) {
        
                    System.out.print(array[i] + " ");
                }
            }
            System.out.println("哈哈");
        }

![在这里插入图片描述][777e24dc365d4ca898206fac0bd6751e.png]  
**由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.**

*  备注：catch 进行类型匹配的时候，不光会匹配相同类型的异常对象，也会捕捉目标异常类型的子类对象。
 *  如刚才的代码，ArithmeticException 和 ArrayIndexOutOfBoundsException 都是 Exception 的子类，因此都能被捕获到

#### catch在捕获异常的时候最好是捕获具体的异常类型（捕获的时候最好是先捕获子类的异常，然后在捕获父类的异常，不然就会报错） ####

现在我们知道 ArithmeticException 和 ArrayIndexOutOfBoundsException 都是 Exception 的子类  
如果我们先捕获父类的异常，此时就会报错

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                int a = 10 / 0;
                System.out.println(array[10]);
                System.out.println("hello");
            }catch(Exception e){
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常或者捕捉到了算数异常,然后处理异常");
            }catch(ArrayIndexOutOfBoundsException | ArithmeticException e) {
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常或者捕捉到了算数异常,然后处理异常");
            }
            System.out.println("哈哈");
        }

![在这里插入图片描述][4299dd800ecc4e82bb4783406121a899.png]  
所以我们要**先捕获子类的异常**

public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            try{
        
                int a = 10 / 0;
                System.out.println(array[10]);
                System.out.println("hello");
            }catch(ArrayIndexOutOfBoundsException | ArithmeticException e) {
        
                e.printStackTrace();
                System.out.println("捕捉到了数组越界异常或者捕捉到了算数异常,然后处理异常");
            } catch(Exception e){
        
                e.printStackTrace();
                System.out.println("捕捉父类的异常");
            }
            System.out.println("哈哈");
        }

![在这里插入图片描述][5c7aead6c86743438ad741b392054d35.png]

#### 代码示例6 finally 表示最后的善后工作, 例如释放资源 ####

比如我么要在控制台上面输入数据，Scanner也是一种资源，打开了之后，就要进行关闭

public static void main(String[] args) {
        
            Scanner scanner = new Scanner(System.in);
    
            try{
        
                int a = scanner.nextInt();
                int b = 10 / a;
                System.out.println("b = " + b);
            }catch(ArithmeticException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了算数异常");
            }
            scanner.close();//关闭资源
        }

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

public static void main(String[] args) {
        
            Scanner scanner = new Scanner(System.in);
    
            try{
        
                int a = scanner.nextInt();
                int b = 10 / a;
                System.out.println("b = " + b);
            }catch(ArithmeticException e){
        
                e.printStackTrace();
                System.out.println("捕捉到了算数异常");
            }finally {
        
                scanner.close();//关闭资源
                System.out.println("Scanner关闭了");
            }
        }

![在这里插入图片描述][a714ae5399224459a27cd6694f18587b.png]  
**所以finally\{ \} 包含的代码，无论有没有捕捉到异常都会被 执行**

刚才的代码Scanner在new对象的时候，是在try 外面的，现在还有一种等价的写法

public static void main(String[] args) {
        
    
            try (Scanner scanner = new Scanner(System.in)) {
        
                int a = scanner.nextInt();
                int b = 10 / a;
                System.out.println("b = " + b);
            } catch (ArithmeticException e) {
        
                e.printStackTrace();
                System.out.println("捕捉到了算数异常");
            } finally {
        
                //关闭资源
                System.out.println("Scanner关闭了");
            }
        }

![在这里插入图片描述][4a23f534e5d14fb094b7900651be75ff.png]

#### 如果我们没有捕捉到异常，异常交给JVM处理，那finally会被执行吗？？？ ####

public static void main(String[] args) {
        
            try (Scanner scanner = new Scanner(System.in)) {
        
                int a = scanner.nextInt();
                int b = 10 / a;
                System.out.println("b = " + b);
            } catch (NullPointerException e) {
        
                e.printStackTrace();
                System.out.println("捕捉到了算数异常");
            } finally {
        
                //关闭资源
                System.out.println("Scanner关闭了");
            }
        }

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

#### 2.4.1、尽量避面在finally中使用return ####

##### 代码示例 #####

public static int func(){
        
            try{
        
                return 2;
            }catch(ArithmeticException e){
        
                e.printStackTrace();
            }finally {
        
                return 100;
            }
        }
    
        public static void main(String[] args) {
        
            System.out.println(func());
        }

![在这里插入图片描述][64b9c9553fca4524a8ab6cdad23ced56.png]

### 2.5、异常处理流程 ###

*  程序先执行 try 中的代码
 *  如果 try 中的代码出现异常，就会结束 try 中的代码，看和 catch 中的异常类型是否匹配.
 *  如果找到匹配的异常类型，就会执行 catch 中的代码
 *  如果没有找到匹配的异常类型，就会将异常向上传递到上层调用者.
 *  无论是否找到匹配的异常类型，finally 中的代码都会被执行到(在该方法结束之前执行).
 *  如果上层调用者也没有处理的了异常，就继续向上传递.
 *  一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理，此时程序就会异常终止

### 2.6、抛出异常 ###

> 除了 Java 内置的类会抛出一些异常之外, 程序猿也可以手动抛出某个异常. 使用 throw 关键字完成这个操作  
> ![在这里插入图片描述][c5cf918bb70a4ac28caee66c92068a75.png]

## 四、自定义异常 ##

Java 中虽然已经内置了丰富的异常类，但是我们实际场景中可能还有一些情况需要我们对异常类进行扩展，创建符合我们实际情况的异常.

#### 不抛异常的用户登录代码实例 ####

如果我们不抛异常，那这个用户登录代码实现：

public class Test {
        
        public static String name = "baidu";
        public static String password = "123456";
    
        public static void login(String name, String password){
        
            if(!Test.name.equals(name)){
        
                System.out.println("用户名错误！");
                return;
            }
            if(!Test.password.equals(password)){
        
                System.out.println("密码错误！");
                return;
            }
            System.out.println("登录成功！");
        }
    
        public static void main(String[] args) {
        
            login("baidu","123456");
        }
    }

如果我们发现用户名或者密码错误。此时就可以抛出自定义异常  
但是自定义异常都要继承系统异常，然后在重写构造方法  
此时我们在处理用户名密码错误的时候可能就需要抛出两种异常. 我们可以基于已有的异常类进行扩展(继承), 创建和我们业务相关的异常类.

#### 继承受查异常（Exception ），那就要搭配try - catch使用或者使用throws声明 ####

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

#### 继承非受查异常RuntimeException ####

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

#### 抛异常的用户登录代码实例 ####

class NameException extends RuntimeException{
        
        public NameException(String message) {
        
            super(message);
        }
    }
    class PasswordRuntimeException extends RuntimeException{
        
        public PasswordRuntimeException(String massage){
        
            super(massage);
        }
    }
    public class Test2 {
        
        public static String name = "baidu";
        public static String password = "123456";
    
        public static void func(int x)  {
        
    
        }
    
        public static void login(String name, String password){
        
            if(!Test2.name.equals(name)){
        
                throw new NameException("用户名错误！");
            }
            if(!Test2.password.equals(password)){
        
                throw new PasswordRuntimeException("密码错误！");
            }
            System.out.println("登录成功！");
        }
    
        public static void main(String[] args) {
        
            login("baidu","123456");
        }
    }

![在这里插入图片描述][01572ba829454ebea3a39f7dfd26cda5.png]

### 4.1、注意事项 ###

*  自定义异常通常会继承自 Exception 或者 RuntimeException
 *  继承自 Exception 的异常默认是受查异常
 *  继承自 RuntimeException 的异常默认是非受查异常

[4194e09d73aa4d15beb0da8a238d1b6f.png]: https://img-blog.csdnimg.cn/4194e09d73aa4d15beb0da8a238d1b6f.png
[3c78afc18c414fbd90d93cd40f69624c.png]: https://img-blog.csdnimg.cn/3c78afc18c414fbd90d93cd40f69624c.png
[64ed783637c644cc833acf1b7f599a51.png]: https://img-blog.csdnimg.cn/64ed783637c644cc833acf1b7f599a51.png
[f21c172da7014d2f901050903674fa34.png]: https://img-blog.csdnimg.cn/f21c172da7014d2f901050903674fa34.png
[cac20d41245a4ce598d64a45e1553323.png]: https://img-blog.csdnimg.cn/cac20d41245a4ce598d64a45e1553323.png
[ff4af501b6e048a181f18a3271fb6748.png]: https://img-blog.csdnimg.cn/ff4af501b6e048a181f18a3271fb6748.png
[071d15d37a9d43debc872d52ab75cb52.png]: https://img-blog.csdnimg.cn/071d15d37a9d43debc872d52ab75cb52.png
[bfd41699c18c4cdba5aaa38791895235.png]: https://img-blog.csdnimg.cn/bfd41699c18c4cdba5aaa38791895235.png
[9f3a0db4b0c14b798f8dd1866d88956f.png]: https://img-blog.csdnimg.cn/9f3a0db4b0c14b798f8dd1866d88956f.png
[a857a30c8d6945cbb04c51a81b3dc371.png]: https://img-blog.csdnimg.cn/a857a30c8d6945cbb04c51a81b3dc371.png
[816cbd65391c49269d1f677700a4155f.png]: https://img-blog.csdnimg.cn/816cbd65391c49269d1f677700a4155f.png
[cb8898e8910f4aeeae3518f1602005b7.png]: https://img-blog.csdnimg.cn/cb8898e8910f4aeeae3518f1602005b7.png
[777e24dc365d4ca898206fac0bd6751e.png]: https://img-blog.csdnimg.cn/777e24dc365d4ca898206fac0bd6751e.png
[4299dd800ecc4e82bb4783406121a899.png]: https://img-blog.csdnimg.cn/4299dd800ecc4e82bb4783406121a899.png
[5c7aead6c86743438ad741b392054d35.png]: https://img-blog.csdnimg.cn/5c7aead6c86743438ad741b392054d35.png
[a061d6b5cc23424a98596d6b0d9aa663.png]: https://img-blog.csdnimg.cn/a061d6b5cc23424a98596d6b0d9aa663.png
[a714ae5399224459a27cd6694f18587b.png]: https://img-blog.csdnimg.cn/a714ae5399224459a27cd6694f18587b.png
[4a23f534e5d14fb094b7900651be75ff.png]: https://img-blog.csdnimg.cn/4a23f534e5d14fb094b7900651be75ff.png
[e01f2899caad47de8500dc8a47782a07.png]: https://img-blog.csdnimg.cn/e01f2899caad47de8500dc8a47782a07.png
[64b9c9553fca4524a8ab6cdad23ced56.png]: https://img-blog.csdnimg.cn/64b9c9553fca4524a8ab6cdad23ced56.png
[c5cf918bb70a4ac28caee66c92068a75.png]: https://img-blog.csdnimg.cn/c5cf918bb70a4ac28caee66c92068a75.png
[bdda9d5f75334de2b37ab2bc9c392022.png]: https://img-blog.csdnimg.cn/bdda9d5f75334de2b37ab2bc9c392022.png
[bdbbfe794de14274b8a7b2d7c73e37ac.png]: https://img-blog.csdnimg.cn/bdbbfe794de14274b8a7b2d7c73e37ac.png
[01572ba829454ebea3a39f7dfd26cda5.png]: https://img-blog.csdnimg.cn/01572ba829454ebea3a39f7dfd26cda5.png