【Java SE】异常的认识

清疚 2024-04-08 13:07 153阅读 0赞

![b4e6ca8983a34017be11d504193bfa0e.png][] 篮球哥温馨提示：编程的同时不要忘记锻炼哦！

## 去爪哇岛旅行会不会提升代码功力呢？ ##

--------------------

**目录**

1、简单认识异常

2、异常的体系结构

3、异常的分类

3.1 编译时异常

3.2 运行时异常

4、如何处理异常？

4.1 异常的抛出

4.2 异常的捕获

4.2.1 throws 关键字

4.2.2 try 和 catch 关键字

4.2.3 finally 关键字

4.2.4 finally 的执行时机是什么？

4.3 异常处理的流程

5、自定义异常类

--------------------

## **1、简单认识异常** ##

在我们程序执行的过程中，发生不正常的行为称为异常，就比如我们常见的数组下标越界，对空引用进行使用也就是空指针异常，再者还碰到过除数为 0 时发生的算数异常。

**算数异常：**

System.out.println(5/0);
    //Exception in thread "main" java.lang.ArithmeticException: / by zero

**数据越界异常：**

int[] array = { 1,2,3,4,5 };
    System.out.println(array[10]);
    //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10

**空指针异常：**

int[] array = null;
    System.out.println(array.length);
    //Exception in thread "main" java.lang.NullPointerException

通过观察//我们上面几个常见的异常例子，可以通过编译器输出的信息，观察到每个异常都有与其对应的类来进行描述，比如果空指针异常，描述他的类就是在 java.lang 包里面的NullPointerException 类里面！

--------------------

## **2、异常的体系结构** ##

异常种类是非常多的，上述我们只是举例我们目前阶段常见的几个异常，为了对不同异常或错误进行更好的分类和管理，Java内部维护了一个异常的体系结构：

![450f172f78644fec8293772243c632e1.png][]

像最右边的运行时异常，还有很多子类，比如上面举例的数组越界啊等等，最左边的IO异常也有很多子类，这里就不一一列举了。

从上面的图我们也可也分析到：Throwable 是异常体系的顶层类，派生出两个重要的子类，分别是Error 和 Exception。

**Error：**指的是Java虚拟机无法解决的严重问题，比如栈溢出，堆资源耗尽，JVM内部错误等，一旦发生了就没有回天之术了！

**Exception：**这个指的是产生了异常之后，程序员可以通过对代码进行处理，使程序继续执行，好比如说我除数写成 0 了，我发现异常了，我修改即可，我们平时说的异常就是Exception！

**今天我们不讨论Error主要讨论Exception**

--------------------

## **3、异常的分类** ##

对于Java中的异常，可能在程序编译时发生，也可能在程序运行时发生，所以根据他们发生的时机不同，我们可以讲异常分为：编译时异常和运行时异常：

### 3.1 编译时异常 ###

在程序编译的期间发生的异常，称为编译时异常，也可以称为受检查异常(CheckedException)，此时如果程序想要编译，必须处理掉这个异常！

比如：我们写一个Student类，里面重写 Object 类中的 clone 方法：

class Student {
        private String name = "zhangsan";
        private int age = 14;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return (Student)super.clone();
        }
    }

这里 throws 关键字先不用管，他是声明异常的，就是声明这个 clone 这个方法可能会发生这个异常，但不进行处理，交给调用者处理，后面会讲。

首先重写这个方法肯定是没有任何问题的，那我们现在来看到在main函数中调用这个方法会出现什么问题：

![538968e0903547318835066b976652de.png][]

这里显示有一个**未处理的异常**，因为 Object 类中 clone 方法抛出了 CloneNotSupportedException异常，而这个异常类继承了 Exception 异常类，默认是编译时异常！这些我们后面都会学习！解决方法你可以接着声明这个异常交给JVM处理，等学完后面的内容就明白了。

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

在程序执行期间发生的异常，称为运行时异常，也可也称为非受检查异常(UncheckedException)，在 RuntimeException 以及其子类对应的异常，都称之为运行时异常，比如前面的空指针异常，数组越界异常，运行时异常编译是可以正常通过的！比如：

![5598515dd86243d9825ecca5042c7e83.png][]

这里就是在运行程序的时候发生的异常，也就是运行时异常！

> **注意：**
> 
> 如果编译时出现的是语法错误，不能把它称之为异常，比如把 System.out.println 的大写 S 写成了小写 s ，这种在编译过程中就会出错，是在"编译期"出错，而运行时异常指的是程序已经编译通过得到了对应的字节码文件，在由JVM执行过程中出现的错误！

--------------------

## **4、如何处理异常？** ##

在Java中，处理异常主要有这五个关键字：**thorw** 抛出异常，**try** 里面放可能出现的异常代码，**catch** 捕捉异常，**finally** 必须执行的特定代码，**thorws** 声明异常。

### 4.1 异常的抛出 ###

前面都是Java自己的异常，编译器帮我们输出的，那其实我们也可以自己手动抛出异常，也可也自定义异常(后面讲)，那如何抛出异常呢？可以借助 thorw 关键字，抛出一个指定的异常对象，将错误信息告诉给调用者。

> 语法格式：**throw new xxxException("出现异常的原因");**

比如说我们要写一个方法，来获取数组对应下标的值，这里当用户传递的数组为null，我们就可以手动抛出异常，输入的下标越界了，我们也可以手动抛出异常：

public class TestDemo {
        public static int getArrayValue (int[] array, int index) {
            if (array == null) {
                throw new NullPointerException("getArrayValue::传递的数组为空！");
            }
            if (index < 0 || index >= array.length) {
                throw new ArrayIndexOutOfBoundsException("getArrayValue::数组下标越界了！");
            }
            System.out.println("测试抛出异常后会不会执行后续代码！");
            return array[index];
        }
        
        public static void main(String[] args) {
            int[] array = {1,2,3,4,5};
            int ret = getArrayValue(array, 10);
            System.out.println(ret);
        }
    }

当我们运行这个 main 方法，手动抛出异常和不手动抛出有什么区别呢？

![d9fe3bb19d964ba4b6eab16916ddd486.png][]

这里区别就交给小伙伴自己去体会了！其实没啥区别，你 new 对象时构造方法不传要打印的错误信息其实就跟编译器自己抛出的异常几乎是一样的了。

> **这里我们手动抛异常需要注意几个点：**
> 
>  *  throw关键字必须写在方法体的内部
>  *  抛出的异常必须是 Exception 或者 Exception 的子类对象
>  *  **如果抛出的是 RuntimeException 或者 RuntimeException 的子类，也就是抛出运行时异常，则可以不用处理，交给编译器处理！**
>  *  **如果抛出的是编译时异常，则必须处理了才能进行编译**
>  *  异常一旦抛出了，其后面的代码将不会执行！(上述代码执行的例子也能看出来)

### 4.2 异常的捕获 ###

既然我们抛出了异常，而且只要异常抛出了，就不会执行后面的代码，那要是我们仍然想执行后面的代码怎么办？就比如你没有手机卡就不能打电话，但是你仍然可以打开打电话的App！不能说我只要发现了一个异常，我程序就直接终止了！

#### 4.2.1 throws 关键字 ####

**在捕获异常之前，我们要先来学习下 thows 关键字，也就是异常的声明：**

thows关键字是写在方法声明时参数列表的后面，当方法中抛出编译时异常，如果该方法内部不想处理该异常，就可以借助 throws 关键字声明可能出现这个异常，但是并不进行处理，而是将异常抛给方法的调用者，提醒方法的调用者来处理这个异常。

> **语法格式：**
> 
> 修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...\{
> 
> \}

假设我们有一个方法，里面可能会发生异常，但是我们不想处理这个异常，那么就可以声明这个异常，那交给谁处理呢？谁调用了这个方法谁处理，假设是 main 方法调用了，就由 main 方法处理，如果 main 方法也不想处理，也可以使用 throws 声明这个异常，即交给JVM处理，如何自己处理异常，后面的 try - catch 就会讲到！

> **注意点：** 
> 
>  *  throws 必须跟在方法的参数列表后面，声明的异常必须是 Exception 或者 Exception 子类！
>  *  如果抛出了多个异常，throws 必须跟多个异常类型，之间使用逗号进行隔开，如果抛出的异常有父子关系，可以直接声明父类(不推荐！)

#### 4.2.2 try 和 catch 关键字 ####

通过上述的 throws 的讲解，我们发现他并没有真正的解决异常，而是将异常报告给抛出异常方法的调用者，由调用者去解决，如果一层层往上抛，最终会交给JVM解决，所以我们如果要真正的解决异常，就需要使用 try - catch 关键字：

> **语法格式：**
> 
> **try** \{
> 
> // 将可能出现异常的代码放在这里
> 
> \} **catch**(要捕获的异常类型 ex) \{  
> // 对捕获的异常进行处理
> 
> \}

如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类 时，就会被捕获到，对异常就可以正常处理，处理完成后，跳出 try - catch 结构，继续执行后序代码！

**这里 try 代码块中也可能不会抛出异常！**

这里我们举一个例子，上面写过获取数组对应下标的值，这里我们就改造一下，获取对应数组两个下标的值，把这两个值放到 ret 数组中并返回，首先这个程序是可能会出现异常的，比如传过来的数组是 null，或者获取的下标越界了，我们就考虑这两个异常，那么改如何实现这个代码呢？

public class TestDemo {
        public static int[] getArrayValue (int[] array, int index1, int index2) {
            int[] ret = new int[2];
            try {
                ret[0] = array[index1];
                ret[1] = array[index2];
                return ret;
            } catch (NullPointerException ex) {
                System.out.println("getArrayValue::传递的数组为空！");
                ex.printStackTrace();
            } catch (ArrayIndexOutOfBoundsException ex) {
                System.out.println("getArrayValue::数组下标越界了！");
                ex.printStackTrace();
            }
            System.out.println("测试抛出异常捕获并处理后会不会执行后续代码！");
            return null;
        }
    
        public static void main(String[] args) {
            int[] array = { 1,2,3,4,5 };
            int[] ret = getArrayValue(array, 3, 10);
            System.out.println(Arrays.toString(ret));
        }
    }

如果我们执行这个 main 方法的话，捕获到的会是数组越界的异常，而捕获到之后，还会不会执行此方法后续的代码呢？我们来运行看答案：

![016b555c06b54b21bcae859fce7c23c6.png][]

通过测试我们发现，我们捕获的确实是数组越界异常，而仍然可以执行后续的代码，而且程序是正常退出！那么这就是捕获并处理异常，这样做的好处是什么？我们不会因为一个异常而终止我整个程序的运行！对于不太严重的问题，可以记录错误日志，通过监控报警程序可以及时通知程序员，对于可能会恢复的问题(网络相关的场景)，可以进行重试。

**那么看到这，或许有的小伙伴有一个问题，那要是我上面的 main 方法传过去的是空数组并且越界还越界了呢？会抛出两个异常吗？**

答案是不会的！在很前面我们就介绍了，当程序抛出异常，中断程序，但是这里我们捕获了异常，所以在 try 代码块内，try 中抛出的异常之后的代码不会执行，直接去 catch 去匹配，只要捕获了，后面代码就可以执行，上述例子输出也能看得出来。

> **注意：**
> 
> 如果抛出的异常与 catch 时异常类型不匹配，即异常不会被成功捕获，也不会被处理，继续往外抛，直到 JVM 收到后中断程序，异常是按类型来捕捉的！

**如果上述情况异常的处理方式是相同的，我们在 catch 中也可也这样写：**

//数组越界异常或空指针异常
    catch (ArrayIndexOutOfBoundsException | NullPointerException ex) {
        //...code
    }

那么既然数组越界异常和空指针异常的父类都是 Exception 类，那么能不能直接一次性捕获多个异常呢？由于 Exception 类是所有异常类的父类，因此可以用这个类型表示捕捉所有异常，没有任何问题，但是不推荐！这样代码的可读性会大大降低！

//一次性捕获多个异常
    catch (Exceptionn ex) {
        //...code
    }

> **注意：**catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象

那么我们推荐怎么写呢？如果异常之间具有父子关系，一定是子类异常在前面的 catch，父类异常在后面的 catch 不然语法会报错，因为如果父类异常在前，表示着出异常永远不会走到子类异常那里去，如果从逻辑上讲，你就可以这么理解，当我们前面所有的子类都没有捕获到这个异常，我们再交给父类去解决，如下演示：

public static int[] getArrayValue (int[] array, int index1, int index2) {
            int[] ret = new int[2];
            try {
                ret[0] = array[index1];
                ret[1] = array[index2];
                return ret;
            } catch (NullPointerException ex) {
                System.out.println("getArrayValue::传递的数组为空！");
                ex.printStackTrace();
            } catch (ArrayIndexOutOfBoundsException ex) {
                System.out.println("getArrayValue::数组下标越界了！");
                ex.printStackTrace();
            } catch (Exception ex) { //前面我们考虑的异常都没有捕获最后再交给父类解决
                ex.printStackTrace();
            }
            System.out.println("测试抛出异常捕获并处理后会不会执行后续代码！");
            return null;
        }

#### 4.2.3 finally 关键字 ####

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库 连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能 导致有些语句执行不到，finally就是用来解决这个问题的。

> **语法格式：**
> 
> **try** \{
> 
> // 可能会发生异常的代码
> 
> \} **catch**(要捕获的异常类型 ex) \{
> 
> // 对捕获到的异常进行处理
> 
> \} **finally** \{
> 
> // 此处的语句无论是否发生异常，都会被执行到
> 
> \}
> 
> //...code 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

在我们上面的学习中，只要异常被捕获了，try - catch 后面的代码也可也执行，那为什么还需要 finally 呢？

这里我们用一个例子来看一下，实现一个 getData 方法，方法内部输入一个数字，并返回这个数字：

public static int getData() {
            Scanner scanner = null;
            try {
                scanner = new Scanner(System.in);
                int data = scanner.nextInt();
                return data;
            } catch (InputMismatchException ex) {
                ex.printStackTrace();
            } finally {
                System.out.println("finally中代码");
            }
            System.out.println("try-catch-finally之后代码");
            if (null != scanner) {
                scanner.close();
            }
            return 0;
    }

那这里我们有一个问题，如果你是正常输入的，那么将会直接返回 data，并不会走到后面的代码，也就是不会释放输入流，造成资源浪费，所以我们可以把释放输入流语句放到 finally 中，因为 不管是否抛出异常，是否被捕获，finally 中的语句都会被执行。

**finally 中的代码一定会执行的，一般在 finally 中进行一些资源清理的扫尾工作。**

#### 4.2.4 finally 的执行时机是什么？ ####

我们先来看下面这段代码：

public class TestDemo {
        public static int func() {
            try {
                return 1;
            } finally {
                return 2;
            }
        }
        public static void main(String[] args) {
            System.out.println(func());
        }
    }

首先我们要弄清楚，finally 执行的时机是在方法返回之前，如果 try 或 catch 中有 return 语句，会在这个 return 之前执行 finally，如果 finally 中也存在 return 语句，那么就会执行 finally 中的 return 从而不会执行 try 或 catch 原有的 return，**一般我们不建议在 finally 中写 return 语句**，会被编译器当成是一个警告！

### 4.3 异常处理的流程 ###

先是执行 try 中的代码，如果里面的代码发生了异常，就会立刻结束 try 中的代码，不会执行 try 中后续代码，接着会去看 catch 中的异常类型与 try 中发生异常的类型能否匹配，如果找到了匹配的异常类型，则会执行对应 catch 中的代码，如果没有找到匹配的异常类型，就会将异常向上传递到上层调用者，无论是否发生异常，是否匹配，finally 中的代码都会在方法结束前执行！如果上层调用者也没有处理这个异常，就继续向上传递，一直到 main 方法也没有合适的代码处理，就会交给 JVM 来进行处理，这个时候，程序就会异常终止！

--------------------

## **5、自定义异常类** ##

有了上面的学习，我们发现Java中的异常其实都是类，虽然提供很多的异常类，但是不能完全满足我们在开发中的需求，所以就需要我们自定义一些异常类，维护符合我们实际情况的一个异常结构，假设说这里我们模拟简单实现一个登录功能：

这里我们就先输入用户名，再输入密码，这里的逻辑怎么做呢？假设用户名错误，就不会去判断密码是否正确，就直接抛出用户名错误异常，只有用户名匹配上了，我们再去判断对应的密码是否正确，如果不正确，则抛出密码错误异常。

**那么具体怎么自定义一个异常呢？**

*  自定义一个类，然后继承 Exception 或者 RuntimeException 类
 *  实现一个带有 String 类型参数的构造方法，参数也就是出现异常的原因

这里我们就简单的照葫芦画瓢自定义一个异常类：

public class UserNameException extends RuntimeException {
        public UserNameException(String message) {
            super(message);
        }
    }

这里可以看到这个异常类我们继承了 RuntimeException 异常类，接着里面有一个构造方法，调用父类的构造传递了一个字符串，至于父类的实现我们目前可以不管，那么这样，就简单的自定义了一个异常类，现在我们模拟实现下登录系统：

public class TestDemo {
        class UserNameException extends RuntimeException {
            public UserNameException(String message) {
                super(message);
            }
        }
        class UserPasswordException extends RuntimeException {
            public UserPasswordException(String message) {
                super(message);
            }
        }
    
        class Login {
            private String userName = "Mike";
            private String userPassword = "123456";
    
            public void loginInfo(String userName, String userPassword) {
                if (!this.userName.equals(userName)) {
                    throw new UserNameException("用户名错误！");
                } else if (!this.userPassword.equals(userPassword)) {
                    throw new UserPasswordException("用户密码错误！");
                }
            }
        }
        public static void main(String[] args) {
            Login login = new Login();
    
            while (true) {
                Scanner scanner = new Scanner(System.in);
                System.out.print("请输入用户名: ");
                String name = scanner.nextLine();
                System.out.print("请输入密码: ");
                String password = scanner.nextLine();
                try {
                    login.loginInfo(name, password);
                    break;
                } catch (UserNameException ex) {
                    ex.printStackTrace();
                } catch (UserPasswordException ex) {
                    ex.printStackTrace();
                }
                System.out.println("登录失败，请重新登录！");
            }
            System.out.println("登陆成功，执行后续代码....");
        }
    }

**测试结果：**

![1deaa1d959d64677a8376519f264727e.png][]

以上代码就是在 loginInfo 方法中可能会抛出用户名错误或者密码错误的异常，然后在 main 方法中去处理了这个异常，直到输入正确才执行 main 方法后续的代码，这只是简单的巩固下异常的运用。

> **注意：**
> 
> **如果自定义异常类继承了 Exception类，默认是受检查异常(编译时异常)**
> 
> **如果自定义异常类继承了 RuntimeException，默认是不受检查异常(运行时异常)**

--------------------

![96348b58a46f44b9a79d7ae34f6280f5.png][]

**下期预告：【Java SE】认识泛型**

[b4e6ca8983a34017be11d504193bfa0e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/38be507ee8bf47b3be9dfc23268e0caf.png
[450f172f78644fec8293772243c632e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/db74b617611d444c84bdcec9507898ed.png
[538968e0903547318835066b976652de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/b8c3f304239446f5a65143588dca783a.png
[5598515dd86243d9825ecca5042c7e83.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2a95679b8ba748d4b70ce403cc995bec.png
[d9fe3bb19d964ba4b6eab16916ddd486.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/792b0d15b8694252b019fbaea85615c5.png
[016b555c06b54b21bcae859fce7c23c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/8d3e26d76cfe4404bc6424e61eae483d.png
[1deaa1d959d64677a8376519f264727e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/2bd68802b8e34dd39b9d85822926552c.png
[96348b58a46f44b9a79d7ae34f6280f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a329b7d19d414356abdac7c1a1336f67.png