Java之异常的详细总结

梦里梦外; 2023-09-28 23:11 85阅读 0赞

> 今天来总结一下Java的异常相关知识点

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

*   *  1.异常
     *  2.异常的继承体系
     *  2.异常的处理流程
     *  4.自定义异常类型

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

### 1.异常 ###

> **定义： 在Java中，将程序执行过程中发生的一些不正常行为称之为"异常"。常见的两大异常有越界异常（IndexOutOfBoundsException）和空指针异常（NullPointerException）。**

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

### 2.异常的继承体系 ###

继承体系图：  
![在这里插入图片描述][0d4751cd304d4c5a9ff4a2b39bf78d30.png]

> 从上图中可以看到：
> 
> 1.  Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
> 2.  Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回力乏术，程序就会直接退出。
> 3.  Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。

**异常的分类（根据异常的发生时机划分）：**

受查异常（编译时异常）︰在程序编译阶段需要显示进行异常处理的异常类，左图中红色框都属于受查异常，常见的有IOException(IO相关的异常)，SQLException(数据库操作相关的异常)。 受查异常必须显示处理，处理方式有两种：1.使用try…catch处理；2.使用throws抛出给JVM处理。这两种方法下面会介绍。

非受查异常（运行时异常）︰在程序运行时发生的异常，不需要显示进行异常处理的异常都是非受查异常。左图中蓝色框都是非受查异常。Error与RuntimeException都是非受查异常，NPE，越界，算术运算都是非受查异常。

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

### 2.异常的处理流程 ###

**异常处理格式：**

try{
        
         //所有可能产生异常的代码块
         //当异常产生时，当前语句后面的语句不再执行，去catch中匹配具体的异常类
    }catch（要捕获的异常类型）{
        //若没有相关的catch块与异常匹配，则程序退出
         //出现异常之后执行的代码
    }[final{
        
         //无论是否发生异常，一定会执行的代码块
         //一般资源关闭操作，网络的关闭操作都放在finally代码块中,保证资源一定会被关闭!!!
    }]   //final为可选代码块(用[]表示了可选可不选) 可写可不写

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

**try…catch代码演示：**

**1：ArithmeticException（算术异常）**

public static void main(String[] args) {
        
            System.out.println("异常产生前的代码");
            try {
        
                System.out.println(10 / 0);
            } catch (ArithmeticException e) {
        
                System.out.println("异常产生了！！！");
            }
            System.out.println("异常产生后的代码");
        }

**结果：**  
![在这里插入图片描述][e9abcd4540a447a88ee8b10d7242f49b.png]

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

**2：若catch中的类型与异常类型不匹配**

public static void main(String[] args) {
        
            System.out.println("异常产生前的代码");
            try {
        
    //            System.out.println(10 / 0);
                String str = null;
                System.out.println(str.length());
            } catch (ArithmeticException e) {
        
                System.out.println("异常产生了！！！");
            }
            System.out.println("异常产生后的代码");
        }

**结果：**  
![在这里插入图片描述][5df8b5c5a33b45af95ee757f84f94f61.png]

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

**3:可能产生多个异常的代码的处理方式**

方式一：多个catch捕获

public static void main(String[] args) {
        
            System.out.println("异常产生前的代码");
            try {
        
                System.out.println(10 / 0);
                String str = null;
                System.out.println(str.length());
            } catch (ArithmeticException e) {
        
                System.out.println("算术异常产生了！！！");
            }catch (NullPointerException e){
        
                System.out.println("空指针异常产生了！！！");
            }
            System.out.println("异常产生后的代码");
        }

**结果:** 正好验证了上面说的//当异常产生时，当前语句后面的语句不再执行，去catch中匹配具体的异常类这句话，只输出了算术异常，没有输出空指针异常。  
![在这里插入图片描述][a565af99409945d899491529cbecf2fd.png]

方式二：使用多态方式，将catch中的异常类改为Exception e，捕获所有子类异常。

public static void main(String[] args) {
        
            System.out.println("异常产生前的代码");
            try {
        
                System.out.println(10 / 0);
                String str = null;
                System.out.println(str.length());
            } catch (Exception e) {
        
                System.out.println("异常产生了！！！");
            }
            System.out.println("异常产生后的代码");
        }

**结果：**  
![在这里插入图片描述][e3ada203453344fab3b8e3185c3cf41b.png]

> 二者选择：推荐使用多个catch来捕获异常，因为多个catch捕获异常我们可以知道该程序段发生了何种异常，便于维护。但是我们可以在循环捕获的最后一个catch里面写Exception来做为保底。

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

**throws和throw抛出异常：**

throws：出现在方法头部，方法的定义上使用 throws 表示这个方法可能抛出某种异常，若throws抛出多个异常，若抛出的异常有父子关系，只需要声明父类异常即可，该抛出需要由方法的调用者进行异常处理。

throw：出现在方法内部，表示方法内抛出某种异常对象，如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常，否则编译报错执行到 throw 语句则后面的语句块不再执行。

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

**补充介绍printStackTrace方法：**

> 我们如何像JVM那样把产生的异常位置返回输出告诉我们呢？这里我们需要使用到printStackTrace方法，该方法捕获到相关异常之后打印异常产生的错误原因以及出现的位置。

public static void main(String[] args) {
        
            System.out.println("异常产生前的代码");
            try {
        
                System.out.println(10 / 0);
            } catch (ArithmeticException e) {
        
                System.out.println("异常产生了！！！");
                e.printStackTrace();
            }
            System.out.println("异常产生后的代码");
        }

**结果：**  
![在这里插入图片描述][568cf7ca57644ed0a0e60428c1bdc9b9.png]

这里大家或许会问：这打印顺序不对呀，printStackTrace方法输出不应该是在 **“异常产生了！！！”** 之后吗？

解释：printStackTrace方法调用的输出是**System.err.println()**,这是一种错误输出，它的输出在控制台为红色字体，且它的优先级低于标准输出**System.out.println()**。

**验证：**

public static void main(String[] args) {
        
            System.out.println("异常产生前的代码");
            try {
        
                System.out.println(10 / 0);
            } catch (ArithmeticException e) {
        
                System.err.println("异常产生了！！！");
                e.printStackTrace();
            }
            System.out.println("异常产生后的代码");
        }

**结果：**  
![在这里插入图片描述][3ac0ca13919d499a94b93a579ca1df4e.png]

> 我将 **“异常产生了！！！”** 设置成错误输出，这时它就和 **printStackTrace()方法的输出** 一起在末尾输出了。

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

### 4.自定义异常类型 ###

> JDK中内置了很多异常类，但是在程序开发过程中，很多场景下出现的问题，JDK中没有相关的异常对应，此时我们就需要根据自己的需求来自定义异常类。

自定义异常类型两步走：   
1.只需要继承Exception(受查)或者RuntimeException(非受查)——>必须显示处理异常的继承Exception，可以不显示处理，就继承RuntimeException。  
2.实现一个带String的有参构造，String方法参数，就是异常的原因。

**用户登录案例：**

public class UserLogin {
        
        private String userName = "admin";
        private String password = "123456";
    
        public static void main(String[] args) {
        
            UserLogin userLogin = new UserLogin();
            try {
        
                userLogin.login("admin", "1234567");
            } catch (PasswordException e) {
        
                e.printStackTrace();
            }
        }
    
        public void login(String userName, String password) throws PasswordException {
        
            if (!this.userName.equals(userName)) {
        
                throw new UserNameException("用户名错误!");
            }
            if (!this.password.equals(password)) {
        
                // 产生异常对象之后需要显示处理
                // 显示处理有两种，要么在当前方法try...catch
                // 要么通过throws向上抛出
                throw new PasswordException("密码错误！");
            }
        }
    
    }
    
    // 密码异常，受查异常，在main里面显示处理了
    class PasswordException extends Exception {
        
        public PasswordException(String msg) {
        
            super(msg);
        }
    }
    
    // 用户名异常,非受查异常
    class UserNameException extends RuntimeException {
        
        public UserNameException(String msg) {
        
            super(msg);
        }
    }

[0d4751cd304d4c5a9ff4a2b39bf78d30.png]: https://img-blog.csdnimg.cn/0d4751cd304d4c5a9ff4a2b39bf78d30.png
[e9abcd4540a447a88ee8b10d7242f49b.png]: https://img-blog.csdnimg.cn/e9abcd4540a447a88ee8b10d7242f49b.png
[5df8b5c5a33b45af95ee757f84f94f61.png]: https://img-blog.csdnimg.cn/5df8b5c5a33b45af95ee757f84f94f61.png
[a565af99409945d899491529cbecf2fd.png]: https://img-blog.csdnimg.cn/a565af99409945d899491529cbecf2fd.png
[e3ada203453344fab3b8e3185c3cf41b.png]: https://img-blog.csdnimg.cn/e3ada203453344fab3b8e3185c3cf41b.png
[568cf7ca57644ed0a0e60428c1bdc9b9.png]: https://img-blog.csdnimg.cn/568cf7ca57644ed0a0e60428c1bdc9b9.png
[3ac0ca13919d499a94b93a579ca1df4e.png]: https://img-blog.csdnimg.cn/3ac0ca13919d499a94b93a579ca1df4e.png