Java异常处理机制

什么是异常？

异常本质上是程序上的错误，错误在我们编写程序的过程中会经常发生，包括编译期间和运行期间的错误。
编译期间的错误通常是基础的语法错误，比如括号没有正常配对、语句结束后少写了分号，关键字编写错误等，编译器会对这些错误给出提示，帮助我们进行修订。
运行期间的错误只有程序运行时才能看到错误的提示，比如数组访问时下标越界、使用空对象调用方法、算术运算时除数为0、类型转换时无法正常转型等，运行期间的错误往往是难以预料的。

程序中的异常

在程序运行过程中，意外发生的情况，背离我们程序本身的意图的表现，都可以理解为异常。
当程序在运行期间出现了异常，如果置之不理，程序可能会不正常运行、强制中断运行、造成用户数据丢失、资源无法正常释放、直接导致系统崩溃,显然这不是我们希望看到的结果。
利用Java中的异常处理机制，我们可以更好地提升程序的健壮性。

异常的分类

在java中，通过Throwable以及它的相关子类来描述各种不同的异常类型。
Throwable是异常的根类，包含两个子类Error和Exception

Throwable类常用方法

String getMessage() 返回保存在某个异常中的描述字符串,异常参数调用
void printStackTrace() 显示堆栈跟踪信息

Error

Error是程序无法处理的错误，表示运行应用程序中较严重问题。
大多数的错误与代码编写所执行的操作是没有什么关系的，而表示代码运行的时候java虚拟机出现的系列问题。
常见的有虚拟机错误、内存溢出、线程死锁等，这些错误往往是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。

Exception

Exception是程序本身可以处理的异常。异常处理通常指的是针对这类异常的处理
Exception类的异常包括Unchecked Exception和Checked Exception
Unchecked Exception(非检查异常)：编译器不要求强制处理的异常，包含RuntimeException以及它的相关子类
Checked Exception(检查异常)：编译器要求必须处理的异常，除了RuntimeException以及它的相关子类其他的Exception子类都是检查异常，如IOException、SQLException

常见的异常类型

异常处理

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

JVM默认处理机制

JVM有一个默认的异常处理机制，即将该异常的名称、异常的信息、异常出现的位置打印在了控制台上，同时将程序停止运行

抛出异常

当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统进行处理。
异常对象通常包含异常类型和异常出现时的程序状态等信息。
运行时系统负责寻找处置异常的代码并执行。
在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器。
运行时系统从发生异常的方法开始，依次回查调用栈中的方法，当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。
当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

捕获异常

对于运行时异常、错误或可查异常，java技术所要求的异常处理方式有所不同。
Java规定对于可查异常必须捕获、或者声明抛出，而允许忽略不可查的RuntimeException(含子类)和Error(含子类)

实现

主要通过5个关键字来实现：try、catch、finally、throw、throws

try-catch-finally

语法格式：

try块：用于捕获异常
catch块：用于处理try捕获到的异常
finally块：无论是否发生异常代码总能执行
try块后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块

执行流程

我们将可能产生异常的代码放入try块当中，当try块中代码没有异常发生时，catch块中的内容不会被执行，而直接执行之后的代码。
当try块发生异常时，会产生一个异常对象且当该类型能与catch块中的异常类型正常匹配时，程序就会进入到catch块执行相应的处理逻辑，然后顺序执行下去。
当出现异常且无法正常匹配处理则程序中断运行

示例

public class TryDemo {
    public static void main(String[] args) {
        //定义两个整数，接受用户的键盘输入，输出两数之商
        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("one和two的商是："+ (one/two));
        System.out.println("=====运算结束=====");
    }
}

程序运行结果

当我们输入的是非数字时，程序会报错并终止运行，报错的异常为InputMismatchException
当我们输入的第二个数为0时，程序也会报错并终止运行，报错的异常为ArithmeticException

使用try-catch-finally对异常进行捕获处理

public class TryDemo {
    public static void main(String[] args) {
        //定义两个整数，接受用户的键盘输入，输出两数之商
        Scanner input=new Scanner(System.in);
        try {
            System.out.println("=====运算开始=====");
            System.out.print("请输入第一个整数：");
            int one=input.nextInt();
            System.out.print("请输入第二个整数：");
            int two=input.nextInt();
            System.out.println("one和two的商是："+ (one/two));
        } catch (Exception e) {
            System.out.println("程序出错啦~~~~");
            e.printStackTrace(); //打印错误的堆栈信息
        }finally{
            System.out.println("=====运算结束=====");
        }
    }
}

此时如果发生上述任意一种错误时，程序会执行catch块中的处理逻辑，然后继续往下执行直到程序结束；
这里catch块中的异常类型为Exception，是所有可处理异常类的基类，所以出现任何类型异常都能匹配上；
而定义在finally块中的逻辑一定会被执行，不管程序是否出现异常。

嵌套try-catch块

如果内部try代码块产生的异常没有被与该try对应的catch捕获，会传到外部try代码块。
使用外部try捕获大部分严重错误的同时，让内部try代码块处理不太严重的错误。

使用多重catch结构处理异常

当程序可能会产生多种类型的异常，针对可能出现的不同异常如果希望做不同的处理，那么就可以使用多重catch
注意多重catch块中的异常类型不能一致，且捕获父类型的catch块应该在子类型的后面，比如Exception应该在最后面

注意事项

一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束，其他的catch子句不再有匹配和捕获异常类型的机会。
对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子句放在前面，同时尽量将捕获相对高层的异常类的catch子句放在后面。否则,捕获底层异常类的catch子句将可能会被屏蔽。

示例

public class TryDemo {
    public static void main(String[] args) {
        //定义两个整数，接受用户的键盘输入，输出两数之商
        Scanner input=new Scanner(System.in);
        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){ //位置应该在最后一个catch块中
            //如果出现的异常没有被前面的catch块匹配，那么在此处进行处理
            System.out.println("出错啦~~");
            e.printStackTrace();
        }finally{
            System.out.println("=====运算结束=====");
        }
    }
}

终止finally执行的方法

上面的程序如果第二个输入的数字为0的话，那么程序就终止了，没有任何打印输出。因为当执行System.exit(1)方法就表示程序无条件终止运行，后面的finally也就不会被执行

return的说明

当代码中出现return时，一定是finally语句块执行完成后才会去执行相应的return代码，无论return语句在什么位置。

示例：

public class TryDemo {
    public static void main(String[] args) {
        int result=test();
        System.out.println("one和two的商是："+ result);
        
    }
    public static int test(){
        Scanner input=new Scanner(System.in);
        System.out.println("=====运算开始=====");
        try{
            System.out.print("请输入第一个整数：");
            int one=input.nextInt();
            System.out.print("请输入第二个整数：");
            int two=input.nextInt();
            return one/two;
        }catch(ArithmeticException e){
            System.out.println("除数不允许为零");
            return 0;
        }finally{
            System.out.println("=====运算结束=====");
            return -100000; //最好不要在finally语句中返回方法结果
        }
    }
}

运行结果

当输入的两个数为36和6时，程序的执行结果为：one和two的商是：-10000
当输入的两个数为36和0时，程序的执行结果为：one和two的商是：-10000
所以当try/catch与finally同时存在return语句返回方法值时，无论程序是否正常执行，最终返回的都是finally的结果

throw和throws

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

throws

throws语句用在方法定义时声明该方法要抛出的异常类型
如果一个方法可能会出现异常，但不想或者没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常
当方法抛出异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理

使用规则

如果是不可查异常(unchecked exception)，即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出
如果一个方法中可能出现可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则编译出错
当抛出了检查异常时，则该方法的调用者必须处理或者重新抛出该异常
当子类重写父类抛出异常的方法时，声明的异常必须是父类方法所声明异常的同类或子类

通过throws抛出异常的解决方案

1.throws后面接多个异常类型，中间用逗号分隔
2.throws后面接Exception，表示任何异常都向外抛出

注意事项

根据throws抛出的异常类型来决定调用者是否必须处理该异常，如果是非检查异常则可以不处理，而如果是检查异常，则必须捕获处理，而Exception也包含了非检查异常，所以也必须进行处理。
对于方法只抛出非检查异常我们可以通过文档注释来标识方法抛出的异常，这样对调用者更友好。

示例

import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemo {
    public static void main(String[] args) {
        //在Eclipse中可以选中代码通过右键Surround With -> Try/Catch Block完成处理异常的代码
        //方案一：针对方法抛出的多个异常进行捕获处理,此时可以只选择捕获处理其中一个异常
        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();
        }
        //方案二：如果方法抛出的是Exception类型，那么catch块中必须包含对Exception的处理，其他子类异常处理是可选的
        try{
            int result = test2();
            System.out.println("one和two的商是：" + result);
        }catch(ArithmeticException e){
            
        }catch(InputMismatchException e){
            
        }catch(Exception e){//这个catch块必须包含
            
        }
    }

    //方案一：throws后面接多个异常类型，中间用逗号分隔
    /**
     * 使用文档注释给出异常提示
     * @return
     * @throws ArithmeticException
     * @throws InputMismatchException
     */
    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后面接Exception，表示任何异常都向外抛出
    public static int test2() 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;
    }
}

throw

throw用来抛出一个异常，例如：throw new IOException();
throw抛出的只能够是可抛出类Throwable或者其子类的实例对象。如：throw new String("出错了");是错误的

throw抛出异常对象的处理方案

1.在throw语句外面套上try-catch块，自己抛出的异常自己处理
2.通过throws在方法声明处抛出异常类型，谁调用方法谁处理，调用者可以自己处理，也可以继续上抛，此时可以抛出与throw对象相同的类型或者其父类

异常抛出与处理作用

规避可能出现的风险
完成一些程序的逻辑

示例：完成酒店入住限定的场景

public class TryDemo {
    public static void main(String[] args) {
        try {
            testAge(); 
        }catch(Exception e){
            //当发生异常时打印：java.lang.Exception: 18岁以下，80岁以上的住客必须由亲友陪同
            e.printStackTrace();
        }
    }
    // 描述酒店的入住规则：限定年龄，18岁以下，80岁以上的住客必须由亲友陪同
    public static void testAge() {
        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();
        }
    }
}

自定义异常

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

示例：我们用自定义异常去描述不满足酒店入住规则的情况

/**
 * 自定义异常
 */
public class HotelAgeException extends Exception {
    public HotelAgeException(){
        super("18岁以下，80岁以上的住客必须由亲友陪同");
    }
}
//测试类
public class TryDemo {
    public static void main(String[] args) {
        try {
            testAge(); 
        } catch (HotelAgeException e) {
            System.out.println(e.getMessage()); //18岁以下，80岁以上的住客必须由亲友陪同
            System.out.println("酒店前台工作人员不允许办理入住登记");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    // 描述酒店的入住规则：限定年龄，18岁以下，80岁以上的住客必须由亲友陪同
    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 HotelAgeException(); //抛出自定义异常
        } else {
            System.out.println("欢迎入住本酒店");
        }
    }
}

异常链

有时候我们会捕获一个异常后再抛出另一个异常。此时异常会如何显示呢？

示例：有三个方法testOne、testTwo、testThree，依次进行调用捕获异常并抛出一个新的异常

public class TryDemo {

    public static void main(String[] args) {
        try {
            testThree();
        } catch (Exception e) {
            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");
        }
    }

    public static void testThree() throws Exception {
        try {
            testTwo();
        } catch (Exception e) {
            throw new Exception("我是新产生的异常2");
        }
    }
}

运行结果

只显示了最后抛出的异常2，前面两个方法的异常信息是丢失的，这就是一种由于新抛出异常导致异常信息丢失的场景，如何将前面的异常信息也保留下来呢，java就提供了这种保留异常信息的机制。

解决方案

可以通过构造方法将异常对象作为参数去构造新的异常对象
调用Throwable提供的initCause方法

修改代码：

    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");
            //通过initCause方法保留异常信息
            e1.initCause(e);
            throw e1;
//          throw new Exception("我是新产生的异常2",e);
        }
    }
}

运行结果：

异常链

当捕获一个异常后再抛出另一个异常时，如果希望将异常发生的原因一个传一个串起来，即把底层的异常信息传给上层,这样逐层抛出而形成的一种链条

Java异常处理的优点

把异常情况表现成异常类，可以充分发挥类的可扩展和可重用的优势
异常流程代码和正常流程的代码分离，提高了程序的可读性，简化了程序的结构
可以灵活的处理异常，有能力处理就捕获并处理，否则就抛出异常，由方法调用者处理它

经验与总结

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