【Java基础系列教程】第九章 Java异常处理机制

小咪咪 2024-04-28 13:14 40阅读 0赞

## 一、异常概述与异常体系结构 ##

### 1.1 异常概述 ###

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。  
  
程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常（开发过程中的语法错误和逻辑错误不是异常）。

Java程序在执行过程中所发生的异常事件可分为两类：  
Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError（栈溢出）和OOM（内存溢出）。一般不编写针对性的代码进行处理。  
Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：  
空指针访问  
试图读取不存在的文件  
网络连接中断  
数组角标越界

**Error示例代码：**

public class ErrorTest {
        public static void main(String[] args) {
            /*
             * 1、栈溢出：java.lang.StackOverflowError
             *   原因 : 函数调用栈太深了,注意代码中是否有了循环调用方法而无法退出的情况
             *   StackOverflowError 是一个java中常出现的错误：在jvm运行时的数据区域中有一个java虚拟机栈，当执行java方法时会进行压栈弹栈的操作。在栈中会保存局部变量，操作数栈，方法出口等等。jvm规定了栈的最大深度，当执行时栈的深度大于了规定的深度，就会抛出StackOverflowError错误。
             * */
            main(args);
    
            /*
             * 2、堆溢出：java.lang.OutOfMemoryError
             *   原因：Java中所有的对象都存储在堆中，通常如果JVM无法再分配新的内存，内存耗尽，垃圾回收无法及时回收内存，就会抛出OutOfMemoryError。
             * */
            Integer[] arr = new Integer[1024 * 1024 * 1024];
    
        }
    }

**Exception示例代码：**

import java.io.FileInputStream;
    
    public class ExceptionTest {
        public static void main(String[] args) {
            /*
             * 1、运行时异常：java.lang.ArithmeticException
             *  原因：ArithmeticException
             * */
            int a = 10;
            int b = 0;
            System.out.println(a / b);
    
            /*
             * 2、编译期异常：java.io.FileNotFoundException
             *   原因：文件找不到异常通常是两种情况：1、系统找不到指定的路径 2、拒绝访问（指定的是目录时，就会报拒绝访问异常）
             * */
            FileInputStream fis = new FileInputStream("a.txt");
    
        }
    }

异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？或者用C语言风格：用函数返回值作为执行状态？

Java提供了更加优秀的解决办法：异常处理机制。异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。  
  
Throwable类是Java异常类型的顶层父类，一个对象只有是 Throwable 类的（直接或者间接）实例，他才是一个异常对象，才能被异常处理机制识别。JDK中内建了一些常用的异常类，我们也可以自定义异常。

### 1.2 异常体系结构 ###

Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及它的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及它的子类，代表程序运行时发生的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

**Error和Exception的区别:**

Error和Exception都有一个共同的根类是Throwable类。  
  
Error是系统中的错误，程序员是不能改变的和处理的，一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。因此我们编写程序时不需要关心这类错误。  
  
Exception，也就是我们经常见到的一些异常情况，表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

**异常体系结构图：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16][]

### 1.3 异常分类 ###

总体上我们根据Javac对异常的处理要求，将异常类分为2类。  
  
我们常说的异常是狭义上的：就是指Exception及其子类，但是广义上的异常是包括Exception和Error；

Java的异常(包括Exception和Error)从广义上分为检查异常（checked exceptions）和非检查的异常（unchecked exceptions）。

其中根据Exception异常进行划分，可分为运行时异常和非运行时异常。

需要明确的是：检查和非检查是对于javac来说的，这样就很好理解和区分了。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_7_color_FFFFFF_t_70_g_se_x_16][]

#### 1.3.1 检查异常 ####

**What:什么是检查异常(checked exception)?**

就是编译器要求你必须处置的异常。不知道你编程的时候有没有遇到过，你写的某段代码，编译器要求你必须要对这段代码try...catch，或者throws exception，如果你遇见过，没错，这就是检查异常，也就是说，你代码还没运行呢，编译器就会检查你的代码，会不会出现异常，要求你对可能出现的异常必须做出相应的处理。

javac强制要求程序员为这样的异常做预备处理工作（使用try...catch...finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

比如:我们调用日期格式化类解析字符串的时候;

**How:怎样处理检查异常（checked exception）?**

1、继续抛出，消极的方法，一直可以抛到java虚拟机来处理，就是通过throws Exception抛出。

2、用try...catch捕获

注意，对于检查的异常必须处理，或者必须捕获或者必须抛出

**Where:检查异常有哪些呢？**

除了RuntimeException与其子类，以及错误（Error），其他的都是检查异常（绝对的大家族）。

#### 1.3.2 非检查异常 ####

**What:什么是非检查异常（unchecked exceptions）？**

编译器不要求强制处置的异常，虽然你有可能出现错误，但是编译器不会在编译的时候检查，没必要，也不可能。

javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try...catch...finally）这样的异常，也可以不处理。

对于这些异常，我们应该修正代码，而不是去通过异常处理器处理。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

**How:对非检查的异常(unchecked exception )怎样处理?**

1、用try...catch捕获  
2、继续抛出  
3、不处理  
4、通过代码处理

一般我们是通过代码处理的，因为你很难判断会出什么问题，而且有些异常你也无法运行时处理，比如空指针，需要人手动的去查找。

而且，捕捉异常并处理的代价远远大于直接抛出。

**Why:为什么有非检查异常？**

你想想非检查异常都有哪些？NullPointerException，IndexOutOfBoundsException，VirtualMachineError等，这些异常你编译的时候检查吗？再说了，明明可以运行时检查，都在编译的时候检查，你写的代码还能看吗？而且有些异常只能在运行时才能检查出来，比如空指针，堆溢出等。

**Where:非检查异常有哪些？**

RuntimeException与其子类，以及错误（Error）。

#### 1.3.3 Exception异常划分 ####

Exception异常进行划分，它可分为运行时异常和编译期异常。

运行时异常：  
是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是非检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

编译期异常：  
是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不要自定义检查异常。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16 1][]

## 二、初识异常与常见异常 ##

### 2.1 初识异常 ###

下面的代码会演示2个异常类型：ArithmeticException 和 InputMismatchException。

前者由于整数除0引发，后者是输入的数据不能被转换为int类型引发。

import java.util.Scanner;
    
    public class AllDemo {
        public static void main(String[] args) {
            System.out.println("----欢迎使用命令行除法计算器----");
            CMDCalculate();
        }
    
        public static void CMDCalculate() {
            Scanner scan = new Scanner(System.in);
            int num1 = scan.nextInt();
            int num2 = scan.nextInt();
            int result = devide(num1, num2);
            System.out.println("result:" + result);
            scan.close();
        }
    
        public static int devide(int num1, int num2) {
            return num1 / num2;
        }
    }
    
    /*****************************************
    ----欢迎使用命令行除法计算器----
    2
    0
    Exception in thread "main" java.lang.ArithmeticException: / by zero
    	at AllDemo.devide(AllDemo.java:19)
    	at AllDemo.CMDCalculate(AllDemo.java:13)
    	at AllDemo.main(AllDemo.java:6)
    
    ----欢迎使用命令行除法计算器----
    ----欢迎使用命令行除法计算器----
    1
    r
    Exception in thread "main" java.util.InputMismatchException
    	at java.util.Scanner.throwFor(Scanner.java:864)
    	at java.util.Scanner.next(Scanner.java:1485)
    	at java.util.Scanner.nextInt(Scanner.java:2117)
    	at java.util.Scanner.nextInt(Scanner.java:2076)
    	at AllDemo.CMDCalculate(AllDemo.java:12)
    	at AllDemo.main(AllDemo.java:6)
    *****************************************/

异常是在执行某个函数时引发的，而函数又是层级调用，形成调用栈的，因为，只要一个函数发生了异常，那么他的所有的caller都会被异常影响。当这些被影响的函数以异常信息输出时，就形成的了异常追踪栈。

异常最先发生的地方，叫做异常抛出点。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16 2][]

从上面的例子可以看出，当devide函数发生除0异常时，devide函数将抛出ArithmeticException异常，因此调用它的CMDCalculate函数也无法正常完成，因此也发送异常，而CMDCalculate的caller——main 因为CMDCalculate抛出异常，也发生了异常，这样一直向调用栈的栈底回溯。这种行为叫做异常的冒泡，异常的冒泡是为了在当前发生异常的函数或者这个函数的caller中找到最近的异常处理程序。由于这个例子中没有使用任何异常处理机制，因此异常最终由main函数抛给JRE，导致程序终止。

上面的代码不使用异常处理机制，也可以顺利编译，因为2个异常都是非检查异常。但是下面的例子就必须使用异常处理机制，因为异常是检查异常。

代码中我选择使用throws声明异常，让函数的调用者去处理可能发生的异常。但是为什么只throws了IOException呢？因为FileNotFoundException是IOException的子类，在处理范围内。

import java.io.FileInputStream;
    import java.io.IOException;
    
    public class ExceptionTest {
        public void testException() throws IOException {
            //FileInputStream的构造函数会抛出FileNotFoundException
            FileInputStream fileIn = new FileInputStream("E:\\a.txt");
    
            int word;
            //read方法会抛出IOException
            while ((word = fileIn.read()) != -1) {
                System.out.print((char) word);
            }
            //close方法会抛出IOException
            fileIn.close();
        }
    }

### 2.2 常见异常 ###

java.lang.RuntimeException: 运行时异常  
ClassCastException: 类类型转换异常，当试图将对象强制转换为不是实例的子类时，抛出该异常；  
ArrayIndexOutOfBoundsException: 数组下标越界异常，当你使用不合法的索引访问数组时会抛出该异常；  
NullPointerException: 空指针异常，通过null进行方法和属性调用会抛出该异常；  
ArithmeticException: 算术运算异常，除数为0，抛出该异常；  
NumberFormatException: 数字转换异常，当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常；  
InputMismatchException: 输入不匹配异常，输入的值数据类型与设置的值数据类型不能匹配。  
...

import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Date;
    import java.util.Scanner;
    
    public class ExceptionTest {
        //ClassCastException
        public void test1() {
            Object obj = new Date();
            String str = (String) obj;
        }
    
        //IndexOutOfBoundsException
        public void test2() {
            //ArrayIndexOutOfBoundsException
            int[] arr = new int[10];
            System.out.println(arr[10]);
    
            //StringIndexOutOfBoundsException
            String str = "abc";
            System.out.println(str.charAt(3));
        }
    
        //NullPointerException
        public void test3() {
            int[] arr = null;
            System.out.println(arr[3]);
    
            String str = "abc";
            str = null;
            System.out.println(str.charAt(0));
        }
    
        //ArithmeticException
        public void test4() {
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        }
    
        //NumberFormatException
        public void test5() {
            String str = "123";
            str = "abc";
            int num = Integer.parseInt(str);
        }
    
        //InputMismatchException
        public void test6() {
            Scanner scanner = new Scanner(System.in);
            int score = scanner.nextInt();
            System.out.println(score);
            scanner.close();
        }
    }

java.io.IOExeption: 输入输出异常  
FileNotFoundException: 文件找不到异常，通常是两种情况：1、系统找不到指定的路径 2、拒绝访问（指定的是目录时，就会报拒绝访问异常）  
EOFException: 文件已结束异常，抛出EOFException一定是因为连接断了还在继续read；

java.lang.ClassNotFoundException: 类找不到异常，当我们通过配置文件去查找一个类的时候，如果配置路径写错，就会抛出该异常，比如：web.xml文件中根本就不存在该类的配置或者配置的路径写错；（比较常见）  
  
java.sql.SQLException: SQL异常，数据库的各种信息的异常；

import java.io.File;
    import java.io.FileInputStream;
    
    public class ExceptionTest {
        
        public void test7() {
            File file = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file);
    
            int data = fis.read();
            while (data != -1) {
                System.out.print((char) data);
                data = fis.read();
            }
    
            fis.close();
        }
    
    }

## 三、异常处理的处理机制 ##

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

在编写代码处理异常时，对于检查异常/非检查异常，都有2种不同的处理方式：  
1、使用try...catch...finally语句块处理它。  
2、在函数签名中使用throws 声明交给函数调用者caller去解决。  
  
比如现有一辆车,这个车你可以是方法,这辆车在可能存在各种风险,那么对于这些风险的处理方式,就相当于异常的处理方式:  
1、使用try...catch...finally语句块处理它。  
我们把这辆车可能出现的问题都考虑清楚了,并提供了备选方案(出现问题怎么做),如果没有出现问题,那么用不到备选方案；  
如果出现了问题，根据问题去找对应的备选方案，以保证车的正常运行；  
如果出现了问题,但是又没备选方案,那么车就跑不了;  
2、在函数签名中使用throws 声明交给函数调用者caller去解决。  
我知道车可能又问题，但是我不处理，谁来使用了，告诉调用者，这里可能有问题；  
那么调用者可以处理这个问题，也可以不处理；如果它不处理，还是会出现问题，如果处理了，肯定没问题；  
A -》 B -》 C

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

Java提供的是异常处理的抓抛模型。  
  
Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。

异常对象的生成:  
由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。  
由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。

异常的抛出机制:  
如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。  
如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。  
程序员通常只能处理Exception，而对Error无能为力。

### 3.1 异常处理机制一：try-catch-finally ###

语法格式：
            try{
                ...... //可能产生异常的代码
            }
            catch( ExceptionName1 e ){
                ...... //当产生ExceptionName1型异常时的处置措施
            }
            catch( ExceptionName2 e ){
                ...... //当产生ExceptionName2型异常时的处置措施
            }
            [ finally{
                ...... //无论是否发生异常，都无条件执行的语句
            } ]
    
    	语法解释：
    		try：
    			捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
    			如果发生异常，则尝试去匹配catch块，catch块可以有多个（因为try块可以出现多个不同类型异常）;
    			如果执行完try不管有没有发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。			
    		catch (Exceptiontype e)：
    			在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
    			每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java可以将多个异常声明在一个catch中。 catch(Exception1 | Exception2 | Exception3 e)
    			catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
    			在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。
    				①、getMessage() 获取异常信息，返回字符串。
    				②、printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
    			如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个函数的外部caller中去匹配异常处理器。
    			如果try中没有发生异常，则所有的catch块将被忽略。
    			注意：如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。比如：可以用 ArithmeticException 类作为参数的地方，就可以用RuntimeException类作为参数，或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常，如NullPointerException（catch中的语句将不会执行）。
    
    		finally：
    			finally块通常是可选的。捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
    			不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。
    			一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
    			finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。

>     public class Test_Input_01 {
>         public static void main(String[] args) {
>             Scanner sc = new Scanner(System.in);
>             /*
>     		 * 当我们只写一个try{}的时候,会报错:
>     		 * 	Syntax error, insert "Finally" to complete TryStatement
>     		 * 	语法错误，插入“Finally”来完成Try块
>     		 * 
>     		 * 总结: try不能单独存在,必须结合catch或finally来使用
>     		 * 	try块中没有异常,会执行finally(如果有)
>     		 *  try块中有异常,会执行对应的catch块(如果有),try中异常发生点之后的代码将不会执行
>     		 */
>             try{
>                 //try块中放可能发生异常的代码。
>                 //如果执行完try且不发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
>                 //如果发生异常，则尝试去匹配catch块。异常点之后的代码不会运行
>     
>                 //这行代码有可能出错
>                 int num1 = sc.nextInt(); //这行代码如果出现异常,那么后面的输出语句就不执行
>     
>                 int num2 = sc.nextInt();
>     
>                 System.out.println(num1+"\t"+num2);
>     
>                 System.out.println(num1/num2);
>     
>     
>                 String str = null;
>                 System.out.println(str.charAt(0));
>     
>             }catch(InputMismatchException | NullPointerException e) { 
>                 // catch(异常对象)	当异常发生了,catch就会捕获对应的异常
>                 // 每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。 catch(Exception1 | Exception2 | Exception3 e)
>                 // catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
>                 // 在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
>                 // 如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个函数的外部caller中去匹配异常处理器。
>                 // 如果try中没有发生异常，则所有的catch块将被忽略。
>                 System.out.println("catch块 - try里面发生了异常 - 空指针和输入不匹配异常都走这个Catch");
>             }catch(java.lang.ArithmeticException e){
>                 e.getMessage();
>                 System.out.println("算数异常:除数不能为0");
>     
>             }catch(Exception e){
>                 System.out.println("程序发生未知异常");
>             }finally {
>                 // finally块通常是可选的。
>                 // 无论异常是否发生，异常是否匹配被处理，finally都会执行。
>                 // 一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
>                 // finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。 
>                 System.out.println("finally块");
>             }
>     
>             System.out.println("异常捕获之后的代码");
>         }
>     }

**需要注意的地方**

1、try块中的局部变量和catch块中的局部变量（包括异常变量），以及finally中的局部变量，他们之间不可共享使用。

2、每一个catch块用于处理一个异常。异常匹配是按照catch块的顺序从上往下寻找的，只有第一个匹配的catch会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配，因此，如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。

3、java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。

有的编程语言当异常被处理后，控制流会恢复到异常抛出点接着执行，这种策略叫做：resumption model of exception handling（恢复式异常处理模式）

而Java则是让执行流恢复到处理了异常的catch块后接着执行，这种策略叫做：termination model of exception handling（终结式异常处理模式）

public static void main(String[] args){
        try {
            foo();
        }catch(ArithmeticException ae) {
            System.out.println("处理异常");
        }
    }
    public static void foo(){
        int a = 5/0;  //异常抛出点
        System.out.println("Look me!!!");  //不会执行
    }

finally块不管异常是否发生，只要对应的try执行了，则它一定也执行。只有一种方法让finally块不执行：System.exit()。因此finally块通常用来做资源释放操作：关闭文件，关闭数据库连接等等。

良好的编程习惯是：在try块中打开资源，在finally块中清理释放这些资源。

需要注意的地方:

1、finally块没有处理异常的能力。处理异常的只能是catch块。

2、在同一try...catch...finally块中 ，如果try中抛出异常，且有匹配的catch块，则先执行catch块，再执行finally块。如果没有catch块匹配，则先执行finally，然后去外面的调用者中寻找合适的catch块。

3、在同一try...catch...finally块中 ，try发生异常，且匹配的catch块中处理异常时也抛出异常，那么后面的finally也会执行：首先执行finally块，然后去外围调用者中寻找合适的catch块。

这是正常的情况，但是也有特例。关于finally有很多恶心，偏、怪、难的问题.

具体在最后一节:finally块和return 讲解

**不捕获异常时的情况：**

前面使用的异常都是RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过( 但运行时会发生异常使得程序运行终止 )。

如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常。

import java.io.*;
    
    public class IOExp {
        public static void main(String[] args) {
            try {
                FileInputStream in = new FileInputStream("hello.txt");
                int b;
                b = in.read();
                while (b != -1) {
                    System.out.print((char) b);
                    b = in.read();
                }
                in.close();
            } catch (IOException e) {
                System.out.println(e);
            } finally {
                System.out.println(" It’s ok!");
            }
        }
    }

### 3.2 异常处理机制二：throws ###

throws是另一种处理异常的方式，它不同于try...catch...finally，throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理。

throws声明：如果一个方法内部的代码会抛出检查异常（checked exception），而方法自己又没有完全处理掉或并不能确定如何处理这种异常，则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理，否则编译不通过。

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

采取这种异常处理的原因可能是：方法本身不知道如何处理这样的异常，或者说让调用者处理更好，调用者需要为可能发生的异常负责。

语法格式：  
修饰符 返回值类型 方法名() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN\{  
//方法内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常，或者他们的子类的异常对象。  
\}

import java.io.*;
    
    public class ThrowsTest {
        public static void main(String[] args) {
            ThrowsTest t = new ThrowsTest();
            try {
                t.readFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public void readFile() throws IOException {
            FileInputStream in = new FileInputStream("hello.txt");
            int b;
            b = in.read();
            while (b != -1) {
                System.out.print((char) b);
                b = in.read();
            }
            in.close();
        }
    }

## 四、手动抛出异常：throw ##

Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。  
throw exceptionObject

程序员也可以通过throw语句手动显式的抛出一个异常。throw语句的后面可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：  
throw new String("你抛我试试.");

throw 语句必须写在函数中，执行throw 语句的地方就是一个异常抛出点，它和由JRE自动形成的异常抛出点没有任何差别。

public class StudentTest {
        public static void main(String[] args) {
            try {
                Student s = new Student();
                s.regist(-1001);
                System.out.println(s);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
    
    class Student {
        private int id;
    
        public void regist(int id) throws Exception {
            if (id > 0) {
                this.id = id;
            } else {
                // System.out.println("您输入的数据非法！");
    
                //手动抛出异常对象
                // throw new RuntimeException("您输入的数据非法！");
                throw new Exception("您输入的数据非法！");
    
                //错误的
                // throw new String("不能输入负数");
            }
    
        }
    
        @Override
        public String toString() {
            return "Student [id=" + id + "]";
        }
    }

**throws和throw的区别:**

throw是语句抛出一个异常。  
语法：throw (异常对象);  
throw e;

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)  
语法：\[(修饰符)\](返回值类型)(方法名)(\[参数列表\])\[throws(异常类)\]\{......\}  
public void doA(int a) throws Exception1,Exception3\{......\}

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。  
throws出现在方法函数头，表示在抛出异常，由该方法的调用者来处理。

throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。  
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。

throws说明你有那个可能，倾向。  
throw的话，那就是你把那个倾向变成真实的了。

两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

## 五、异常的链化 ##

在一些大型的，模块化的软件开发中，一旦一个地方发生异常，则如骨牌效应一样，将导致一连串的异常。假设B模块完成自己的逻辑需要调用A模块的方法，如果A模块发生异常，则B也将不能完成而发生异常，但是B在抛出异常时，会将A的异常信息掩盖掉，这将使得异常的根源信息丢失。异常的链化可以将多个模块的异常串联起来，使得异常信息不会丢失。

异常链化:以一个异常对象为参数构造新的异常对象。新的异对象将包含先前异常的信息。这项技术主要是异常类的一个带Throwable参数的函数来实现的。这个当做参数的异常，我们叫它根源异常（cause）。

查看Throwable类源码，可以发现里面有一个Throwable字段cause，就是它保存了构造时传递的根源异常参数。这种设计和链表的结点类设计如出一辙，因此形成链也是自然的了。

public class Throwable implements Serializable {
        private Throwable cause = this;
    
        public Throwable(String message, Throwable cause) {
            fillInStackTrace();
            detailMessage = message;
            this.cause = cause;
        }
    
        public Throwable(Throwable cause) {
            fillInStackTrace();
            detailMessage = (cause == null ? null : cause.toString());
            this.cause = cause;
        }
    
        //........
    }

下面是一个例子，演示了异常的链化：从命令行输入2个int，将他们相加，输出。输入的数不是int，则导致getInputNumbers异常，从而导致add函数异常，则可以在add函数中抛出一个链化的异常。

public static void main(String[] args){
        System.out.println("请输入2个加数");
        int result;
        try{
            result = add();
            System.out.println("结果:"+result);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    //获取输入的2个整数返回
    private static List<Integer> getInputNumbers(){
        List<Integer> nums = new ArrayList<>();
        Scanner scan = new Scanner(System.in);
        try {
            int num1 = scan.nextInt();
            int num2 = scan.nextInt();
            nums.add(new Integer(num1));
            nums.add(new Integer(num2));
        }catch(InputMismatchException immExp){
            throw immExp;
        }finally {
            scan.close();
        }
        return nums;
    }
    
    //执行加法计算
    private static int add() throws Exception{
        int result;
        try {
            List<Integer> nums =getInputNumbers();
            result = nums.get(0)  + nums.get(1);
        }catch(InputMismatchException immExp){
            throw new Exception("计算失败",immExp);  /链化:以一个异常对象为参数构造新的异常对象。
        }
        return  result;
    }
    
    /*
    请输入2个加数
    r 1
    java.lang.Exception: 计算失败
        at practise.ExceptionTest.add(ExceptionTest.java:53)
        at practise.ExceptionTest.main(ExceptionTest.java:18)
    Caused by: java.util.InputMismatchException
        at java.util.Scanner.throwFor(Scanner.java:864)
        at java.util.Scanner.next(Scanner.java:1485)
        at java.util.Scanner.nextInt(Scanner.java:2117)
        at java.util.Scanner.nextInt(Scanner.java:2076)
        at practise.ExceptionTest.getInputNumbers(ExceptionTest.java:30)
        at practise.ExceptionTest.add(ExceptionTest.java:48)
        ... 1 more
    
    */

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_14_color_FFFFFF_t_70_g_se_x_16][]

## 六、自定义异常 ##

### 6.1 自定义异常规则 ###

如果要自定义异常类，则扩展Exception类即可，因此这样的自定义异常都属于检查异常（checked exception）。如果要自定义非检查异常，则扩展自RuntimeException。

按照国际惯例，自定义的异常应该总是包含如下的构造函数：  
一个无参构造函数  
一个带有String参数的构造函数，并传递给父类的构造函数。  
一个带有String参数和Throwable参数，并都传递给父类构造函数。  
一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

**下面是IOException类的完整源代码，可以借鉴。**

public class IOException extends Exception {
        static final long serialVersionUID = 7818375828146090155L;
    
        public IOException() {
            super();
        }
    
        public IOException(String message) {
            super(message);
        }
    
        public IOException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public IOException(Throwable cause) {
            super(cause);
        }
    }

### 6.2 自定义异常构建 ###

**首先写一个自定义异常，继承Exception，代码如下:**

public class MyException extends Exception {
    
        public MyException() {
            super();
        }
    
        public MyException(String message) {
            super(message);
        }
    
        public MyException(String message, Throwable cause) {
            super(message, cause);
        }
    
    
        public MyException(Throwable cause) {
            super(cause);
        }
    }

### 6.3 使用自定义异常 ###

如果自定义异常是为了提示，在使用的时候，一定要用try..catch，不要直接用throw往外抛。

public class Test {
        public static void main(String[] args) {
            A a = new A();
            try {
                a.show(-2);
            } catch (MyException e) {
                System.out.println(e.getMessage());
            }
        }
    }
    
    class A {
        public void show(int num) throws MyException {
            if (num < 0) {
                MyException me = new MyException("异常：" + num + "不是正数");
                throw me;//抛出异常，结束方法show()的执行
            }
            System.out.println(num);
        }
    }

## 七、异常的注意事项 ##

1、当子类重写父类的带有 throws声明的函数时，其throws声明的异常必须在父类异常的可控范围内——用于处理父类的throws方法的异常处理器，必须也适用于子类的这个带throws方法 。这是为了支持多态。

例如，父类方法throws 的是2个异常，子类就不能throws 3个及以上的异常。父类throws IOException，子类就必须throws IOException或者IOException的子类。

至于为什么？我想，也许下面的例子可以说明。

class Father {
        public void start() throws IOException {
            throw new IOException();
        }
    }
    
    class Son extends Father {
        public void start() throws Exception {
            throw new SQLException();
        }
    }
    
    /**********************假设上面的代码是允许的（实质是错误的）***********************/
    class Test {
        public static void main(String[] args) {
            Father[] objs = new Father[2];
            objs[0] = new Father();
            objs[1] = new Son();
    
            for (Father obj : objs) {
                // 因为Son类抛出的实质是SQLException，而IOException无法处理它。
                // 那么这里的try。。catch就不能处理Son中的异常。
                // 多态就不能实现了。
                try {
                    obj.start();
                } catch (IOException ioException) {
                    // 处理IOException
                }
            }
        }
    }

2、Java程序可以是多线程的。每一个线程都是一个独立的执行流，独立的函数调用栈。如果程序只有一个线程，那么没有被任何代码处理的异常会导致程序终止。如果是多线程的，那么没有被任何代码处理的异常仅仅会导致异常所在的线程结束。

也就是说，Java中的异常是线程独立的，线程的问题应该由线程自己来解决，而不要委托到外部，也不会直接影响到其它线程的执行。

## 八、finally块和return ##

**1、一个不容易理解的事实：在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行。**

public static void main(String[] args){
        int re = bar();
        System.out.println(re);
    }
    private static int bar() {
        try{
            return 5;
        } finally{
            System.out.println("finally");
        }
    }
    /*输出：
    finally
    5
    */

**2、finally中的return 会覆盖 try 或者catch中的返回值。**

public static void main(String[] args){
        int result;
    
        result  =  foo();
        System.out.println(result);     /2
    
        result = bar();
        System.out.println(result);    /2
    }
    
    @SuppressWarnings("finally")
    public static int foo(){
        try{
            int a = 5 / 0;
        } catch (Exception e){
            return 1;
        } finally{
            return 2;
        }
    
    }
    
    @SuppressWarnings("finally")
    public static int bar(){
        try {
            return 1;
        }finally {
            return 2;
        }
    }

**3、finally中的return会抑制（消灭）前面try或者catch块中的异常**

class TestException {
        public static void main(String[] args) {
            int result;
            try {
                result = foo();
                System.out.println(result);           //输出100
            } catch (Exception e) {
                System.out.println(e.getMessage());    //没有捕获到异常
            }
    
    
            try {
                result = bar();
                System.out.println(result);           //输出100
            } catch (Exception e) {
                System.out.println(e.getMessage());    //没有捕获到异常
            }
        }
    
        //catch中的异常被抑制
        @SuppressWarnings("finally")
        public static int foo() throws Exception {
            try {
                int a = 5 / 0;
                return 1;
            } catch (ArithmeticException amExp) {
                throw new Exception("我将被忽略，因为下面的finally中使用了return");
            } finally {
                return 100;
            }
        }
    
        //try中的异常被抑制
        //J2SE 提供的最后一个批注是 @SuppressWarnings。该批注的作用是给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默。
        @SuppressWarnings("finally")
        public static int bar() throws Exception {
            try {
                int a = 5 / 0;
                return 1;
            } finally {
                return 100;
            }
        }
    }

**4、finally中的异常会覆盖（消灭）前面try或者catch中的异常**

public class TestException {
        public static void main(String[] args) {
            int result;
            try {
                result = foo();
            } catch (Exception e) {
                System.out.println(e.getMessage());    //输出：我是finaly中的Exception
            }
    
    
            try {
                result = bar();
            } catch (Exception e) {
                System.out.println(e.getMessage());    //输出：我是finaly中的Exception
            }
        }
    
        //catch中的异常被抑制
        @SuppressWarnings("finally")
        public static int foo() throws Exception {
            try {
                int a = 5 / 0;
                return 1;
            } catch (ArithmeticException amExp) {
                throw new Exception("我将被忽略，因为下面的finally中抛出了新的异常");
            } finally {
                throw new Exception("我是finally中的Exception");
            }
        }
    
        //try中的异常被抑制
        @SuppressWarnings("finally")
        public static int bar() throws Exception {
            try {
                int a = 5 / 0;
                return 1;
            } finally {
                throw new Exception("我是finally中的Exception");
            }
    
        }
    }

**上面的3个例子都异于常人的编码思维，因此我建议：**

不要在fianlly中使用return。

不要在finally中抛出异常。

减轻finally的任务，不要在finally中做一些其它的事情，finally块仅仅用来释放资源是最合适的。

将尽量将所有的return写在函数的最后面，而不是try ... catch ... finally中。

## 九、课后练习题 ##

### 9.1 程序题 ###

**1、判断程序的输出结果**

public class ReturnExceptionDemo {
        static void methodA() {
            try {
                System.out.println("进入方法A");
                throw new RuntimeException("制造异常");
            } finally {
                System.out.println("用A方法的finally");
            }
        }
    
        static void methodB() {
            try {
                System.out.println("进入方法B");
                return;
            } finally {
                System.out.println("调用B方法的finally");
            }
        }
    
        public static void main(String[] args) {
            try {
                methodA();
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
            methodB();
        }
    }
    /*
    进入方法A
    用A方法的finally
    制造异常
    进入方法B
    调用B方法的finally
    */

### 9.2 简答题 ###

1、什么是异常?  
程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常;

2、什么是异常处理机制（\*）?  
异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

3、异常对象的生成的两种方式（\*）?  
由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。  
由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。

4、异常的抛出机制（\*）?  
如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。  
如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

5、异常体系结构?  
Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。  
Throwable又派生出Error类和Exception类。  
错误：Error类以及它的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。  
异常：Exception以及它的子类，代表程序运行时发生的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

6、Error和Exception的区别（\*\*\*）?  
Error和Exception都有一个共同的根类是Throwable类。  
Error是系统中的错误，程序员是不能改变的和处理的，一般是指与虚拟机相关的问题,对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。因此我们编写程序时不需要关心这类错误。  
Exception，也就是我们经常见到的一些异常情况，表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

7、Java异常的分类?  
Java的异常从广义上分为检查异常（checked exceptions）和非检查的异常（unchecked exceptions）。  
检查异常: 编译器要求你必须处置的异常。也就是说，你代码还没运行呢，编译器就会检查你的代码，会不会出现异常，要求你对可能出现的异常必须做出相应的处理。  
非检查异常:编译器不要求强制处置的异常，虽然你有可能出现错误，但是编译器不会在编译的时候检查，没必要，也不可能。  
Java的异常从狭义上分为运行时异常和编译期异常。  
运行时异常：是RuntimeException类及其子类异常，这些异常是非检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。  
编译期异常：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。  
检查异常 = 编译期异常;  
非检查异常 = 运行时异常 + Error;

8、什么是检查异常?  
编译器要求你必须处置的异常。也就是说，你代码还没运行呢，编译器就会检查你的代码，会不会出现异常，要求你对可能出现的异常必须做出相应的处理。  
除了RuntimeException与其子类，以及错误（Error），其他的都是检查异常（绝对的大家族）。

9、什么是非检查异常?  
编译器不要求强制处置的异常，虽然你有可能出现错误，但是编译器不会在编译的时候检查，没必要，也不可能。  
RuntimeException与其子类，以及错误（Error）。

10、try...catch...finally的作用（\*\*\*）?  
try块中放可能发生异常的代码。  
catch块用于捕获并处理一个特定的异常,catch块可以有多个;  
finally块无论异常是否发生,异常是否匹配被处理,都会执行,主要做一些清理工作,比如释放资源;  
try必须有,catch和finally都是可选的;但是try不能单独存在,至少要和catch或finally其中一个结合使用;

11、try...catch...finally和throws处理异常的区别（\*）?  
try...catch...finally是在方法内部处理异常,通过统一的异常处理方案;  
throws是方法本身不知道如何处理这样的异常,或者说让调用者处理更好,调用者需要为可能发生的异常负责。

12、throws和throw的区别（\*\*\*）?  
throws定义在方法的声明中,表示调用该方法可能出现一个或多个异常,由该方法的调用者来处理;throws后面跟的是一个或多个异常类型;  
throw定义在方法内部,表示方法体内,表示抛出异常,由方法体内的语句处理;throw语句的后面必须是一个异常对象;  
两者都是消极处理异常的方式,只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用处理。

13、什么是异常链化（\*）?  
异常的链化可以将多个模块的异常串联起来,使得异常信息不会丢失。实现方式:以一个异常对象为参数构造新的异常对象。

14、finally和return代码阅读面试题（\*\*\*） - 规则?  
在try块中即便有return,break,continue等改变执行流的语句,finally也会执行。  
finally中的return会覆盖 try 或者catch中的返回值。  
finally中的return会抑制（消灭）前面try或者catch块中的异常  
finally中的异常会覆盖（消灭）前面try或者catch中的异常

15、finally的使用注意事项（\*\*\*）?  
不要在finally中使用return。  
不要在finally中抛出异常。  
减轻finally的任务,不要在finally中做一些其它的事情,finally块仅仅用来释放资源是最合适的。  
尽量将所有的return写在函数的最后面，而不是try ... catch ... finally中。

16、final，finally和finalize的比较（\*）?  
final修饰类,类不能被继承 final 修饰方法,方法不能被重写，final 修饰变量,变量不能被修改  
finally 是异常语句块的一部分,无论是否有异常,都会被执行  
finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 这个方法的调用是用来回收无用的对象。

17、常见的异常有哪些?  
java.lang.RuntimeException: 运行时异常  
ClassCastException: 类类型转换异常，当试图将对象强制转换为不是实例的子类时，抛出该异常；  
ArrayIndexOutOfBoundsException: 数组下标越界异常，当你使用不合法的索引访问数组时会抛出该异常；  
NullPointerException: 空指针异常，通过null进行方法和属性调用会抛出该异常；  
ArithmeticException: 算术运算异常，除数为0，抛出该异常；  
NumberFormatException: 数字转换异常，当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常；  
InputMismatchException: 输入不匹配异常，输入的值数据类型与设置的值数据类型不能匹配。

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/511bb18845b542cc884c7b23aff22492.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_7_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/b87c5f91d8fb48e6a56592b8da8058e4.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/bae75ab0afce423281f7f985f2bf9deb.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/4fc85f24e4424f2f83b2c9e90467e26c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_14_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2f38880b5f8a4497a30edfd0d7043473.png