Java常用工具之异常

╰+哭是因爲堅強的太久メ 2022-05-15 04:12 185阅读 0赞

# Java常用工具之异常 #

# 一、异常分类 #

在程序开发中，异常指不期而至的各种状况。它是一个事件，当发生在 程序运行期间时，会干扰正常的指令流程。

在Java中，通过Throwable及其子类描述各种不同的异常类型。  
![20180824103002.png][]

Error

*  Error是程序无法处理的错误，表示运行应用程序中较严重问题。大多 数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。
 *  例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不 再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError
 *  这些错误是不可查的，因为它们在应用程序的控制和处理能力之外， 而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应 该试图去处理它所引起的异常状况。因此我们编写程序时不需要关心这类异常。

Exception

*  Exception是程序本身可以处理的异常。异常处理通常指针对这种类型 异常的处理。
 *  Exception类的异常包括 checked exception 和 unchecked exception。
 *  unchecked exception  
    
    
     *  unchecked exception：编译器不要求强制处置的异常。
     *  包含RuntimeException类及其子类异常。
     *  如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常)等，这些异常是 unchecked exception 。
     *  Java编译器不会检查这些异常，在程序中可以选择捕获处理，也可以 不处理，照样正常编译通过。
 *  checked exception  
    
    
     *  checked exception：编译器要求必须处置的异常。
     *  是RuntimeException及其子类以外，其他的Exception类的子类。
     *  如IOException、SQLException等
     *  Java编译器会检查这些异常，当程序中可能出现这类异常时，要求必 须进行异常处理，否则编译不会通过。

# 二、异常处理 #

在Java应用程序中，异常处理机制为：抛出异常、捕捉异常

1、抛出异常  
\- 当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统。  
\- 异常对象中包含了异常类型和异常出现时的程序状态等异常信息。  
\- 运行时系统负责寻找处置异常的代码并执行。

2、捕获异常  
\- 在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器。  
\- 运行时系统从发生异常的方法开始，依次回查调用栈中的方法，当异 常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合 适的异常处理器。  
\- 当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统 终止。同时，意味着Java程序的终止。  
\- 对于运行时异常、错误或可查异常，Java技术所要求的异常处理方式 有所不同。总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许 忽略不可查的RuntimeException和Error。  
\- 简单地说，异常总是先被抛出，后被捕捉的。

**异常处理通过5个关键字来实现：try、catch、 finally、throw、throws**

![20180824103848.png][]

**No.1 try-catch-finally**  
try块后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。

catch、finally可选  
语法组合：

*  try-catch
 *  try-finally
 *  try-catch-finally
 *  try-catch-catch-finally

在try-catch块后加入finally块

*  是否发生异常都执行
 *  不执行的唯一情况如下  
    ![20180824111417.png][]

public void method() {
            try {
                // 代码段 1
                // 产生异常的代码段 2
            } catch (异常类型 ex) {
                // 对异常进行处理的代码段3
            } finally {
                // 代码段 4
            }
        }
    
    //Demo
    
    package com.geekmubai;
    
    import java.util.InputMismatchException;
    import java.util.Scanner;
    
    public class Error {
    
        public static void main(String[] args) {
            // 要求：定义两个整数，接受用户的键盘输入，输出两数之商
            Scanner input=new Scanner(System.in);
            System.out.println("=====运算开始=====");
            try{
                System.out.print("请输入第一个整数：");
                int one=input.nextInt();
                System.out.print("请输入第二个整数：");
                int two=input.nextInt();
                System.out.println("one和two的商是："+ (one/two));
            }catch(ArithmeticException e){
                System.exit(1);//终止程序运行
                System.out.println("除数不允许为零");
                e.printStackTrace();
            }catch(InputMismatchException e){
                System.out.println("请输入整数");
                e.printStackTrace();
            }catch(Exception e){
                System.out.println("出错啦~~");
                e.printStackTrace();
            }finally{
                System.out.println("=====运算结束=====");
            }
        }
    }

**No.2try-catch**  
使用try-catch块捕获并处理异常

public void method() {
            try {
                // 代码段
            } catch (异常类型 ex) {
                // 对异常进行处理的代码段
            }
                // 代码段
        }

异常种类：  
![20180824111030.png][]

**No.3 多重catch块**  
一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理 结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配 和捕获异常类型的机会。

对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的 catch子 句放在前面，同时尽量将捕获相对高层的异常类的catch子句放 在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。

引发多种类型的异常

*  排列catch 语句的顺序：先子类后父类
 *  发生异常时按顺序逐个匹配
 *  只执行第一个与异常类型匹配的catch语句  
    ![20180824111218.png][]

**No.4 异常类型**

**No.5 总结**

实际应用中的经验与总结

*  处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
 *  在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
 *  对于不确定的代码，也可以加上try-catch，处理潜在的异常
 *  尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
 *  具体如何处理异常，要根据不同的业务需求和异常类型去决定
 *  尽量添加finally语句块去释放占用的资源

# 三、声明异常 #

可以通过throws声明将要抛出何种类型的异常，通过throw将产生的 异常抛出。

**throw**

*  如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法 声明处用throws子句来声明抛出异常。
 *  例如：汽车在运行时可能会出现故障，汽车本身没办法处理这个故障， 那就让开车的人来处理。

**throws**  
\- throws语句用在方法定义时声明该方法要抛出的异常类型。

public void method() throws Exception1,Exception2,...,ExceptionN {
    // 可能产生异常的代码
    }

*  当方法抛出异常列表中的异常时，方法将不对这些类型及其子类类型的 异常作处理，而抛向调用该方法的方法，由他去处理。

两种抛出异常的方法

//1、throws抛出大类异常，catch分小类
    package com.geekmubai;
    
    import java.util.InputMismatchException;
    import java.util.Scanner;
    
    public class throw1 {
        
        public static void main(String[] args) {
            try {
                int result = test();
                System.out.println("one和two的商是：" + result);
            } catch (ArithmeticException e) {
            } catch (InputMismatchException e) {
            } catch (Exception e) {
            }
            int result2 = test();
        }
    
        /**
         * 测试接收数据相除结果的方法
         * @return 两个接收数据的商
         * @throws ArithmeticException
         * @throws InputMismatchException
         */
    
        public static int test() throws Exception {
            Scanner input = new Scanner(System.in);
            System.out.println("=====运算开始=====");
            System.out.print("请输入第一个整数：");
            int one = input.nextInt();
            System.out.print("请输入第二个整数：");
            int two = input.nextInt();
            System.out.println("=====运算结束=====");
            return one / two;
        }
    }
    
    
    //2、throws抛出小类异常，catch分小类
    package com.geekmubai;
    
    import java.util.InputMismatchException;
    import java.util.Scanner;
    
    public class throwdemo {
        
        public static void main(String[] args) {
            try {
                int result = test();
                System.out.println("one和two的商是：" + result);
            } catch (ArithmeticException e) {
                System.out.println("除数不允许为零");
                e.printStackTrace();
            } catch (InputMismatchException e) {
                System.out.println("请输入整数");
                e.printStackTrace();
            }
        }
    //    通过throws抛出异常时，针对可能出现的多种异常情况，解决方案：
    //    throws后面接多个异常类型，中间用逗号分隔
        public static int test() throws ArithmeticException, InputMismatchException {
            Scanner input = new Scanner(System.in);
            System.out.println("=====运算开始=====");
            System.out.print("请输入第一个整数：");
            int one = input.nextInt();
            System.out.print("请输入第二个整数：");
            int two = input.nextInt();
            System.out.println("=====运算结束=====");
            return one / two;
        }
    }

**throws的使用规则**  
1、如果是不可查异常（unchecked exception），即Error、 RuntimeException或它们的子类，那么可以不使用throws关键字来 声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

2、如果一个方法中可能出现可查异常，要么用try-catch语句捕获， 要么用throws子句声明将它抛出，否则会导致编译错误

3、当抛出了异常，则该方法的调用者必须处理或者重新抛出该异常。

4、当子类重写父类抛出异常的方法时，声明的异常必须是父类方法所 声明异常的同类或子类。

**throw抛出异常对象的处理方案：**  
通过try..catch包含throw语句——自己抛自己处理

try {
                System.out.println("请输入年龄：");
                Scanner input = new Scanner(System.in);
                int age = input.nextInt();
                if (age < 18 || age > 80) {
                    throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
                } else {
                    System.out.println("欢迎入住本酒店");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

通过throws在方法声明出抛出异常类型–谁调用谁处理–调用者可以自己处理，也可以继续上抛。此时可以抛出与throw对象相同的类型或者其父类。

package com.geekmubai;
    
    import java.util.Scanner;
    
    public class throw2 {
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            try {
                testAge();
            } catch (HotelAgeException e) {
                System.out.println(e.getMessage());
                System.out.println("酒店前台工作人员不允许办理入住登记");
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    
        public static void testAge() throws HotelAgeException {
            System.out.println("请输入年龄：");
            Scanner input = new Scanner(System.in);
            int age = input.nextInt();
            if (age < 18 || age > 80) {
                //throw new ArithmeticException();
                //throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
                throw new HotelAgeException();
            } else {
                System.out.println("欢迎入住本酒店");
            }
        }
    }

# 四、自定义异常和异常链 #

自定义异常

*  使用Java内置的异常类可以描述在编程时出现的大部分异常情况。
 *  也可以通过自定义异常描述特定业务产生的异常类型。
 *  所谓自定义异常，就是定义一个类，去继承Throwable类或者它的子类。

异常链

*  有时候我们会捕获一个异常后再抛出另一个异常
 *  顾名思义就是：将异常发生的原因一个传一个串起来，即把底层 的异常信息传给上层，这样逐层抛出

package com.imooc.test;
    
    public class TryDemoFive {
        
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            try {
                testThree();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
        public static void testOne() throws HotelAgeException {
            throw new HotelAgeException();
        }
    
        public static void testTwo() throws Exception {
            try {
                testOne();
            } catch (HotelAgeException e) {
                throw new Exception("我是新产生的异常1",e);
            }
        }
    
        public static void testThree() throws Exception {
            try {
                testTwo();
            } catch (Exception e) {
                Exception e1=new Exception("我是新产生的异常2");
                e1.initCause(e);
                throw e1;
    //          throw new Exception("我是新产生的异常2",e);
            }
        }
    }

[20180824103002.png]: /images/20220515/1dffca61cefd4e1abc27af3f71b1e467.png
[20180824103848.png]: /images/20220515/fbe2b43af57349d49fa6c2ac8717d660.png
[20180824111417.png]: /images/20220515/0d7e7a6cc6da459abc89a51898bd9fe1.png
[20180824111030.png]: /images/20220515/34e008e3b37449fda0e25e6cabfaadec.png
[20180824111218.png]: /images/20220515/bd23e5094d0e436eb662e08373153928.png