Java常用工具之异常

一、异常分类

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

在Java中，通过Throwable及其子类描述各种不同的异常类型。

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

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块

是否发生异常都执行
不执行的唯一情况如下

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("=====运算结束=====");
        }
    }
}

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) {
            // 对异常进行处理的代码段
        }
            // 代码段
    }

public void method() {

try {

// 代码段

} catch (异常类型 ex) {

// 对异常进行处理的代码段

}

// 代码段

}

异常种类：

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

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

引发多种类型的异常

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

No.4 异常类型

|异常类型|说明|
|----|----|
Exception|异常层次结构的父类
|ArithmeticException|算术错误情形，如以零作除数
|ArrayIndexOutOfBoundsException|数组下标越界
|NullPointerException|尝试访问 null 对象成员
|ClassNotFoundException|不能加载所需的类
|IllegalArgumentException|方法接收到非法参数
|ClassCastException|对象强制类型转换出错
|NumberFormatException|数字格式转换异常，如把"abc" 转换成数字

No.5 总结

实际应用中的经验与总结

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

三、声明异常

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

throw

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

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

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

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;
    }
}

//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();
        }
    }

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("欢迎入住本酒店");
        }
    }
}

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);
        }
    }
}

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);

}