# 异常

异常概述
- java异常处理机制
异常分类
- Java异常可以分为可检测异常，非检测异常
- 异常中常用的方法
声明及抛出
捕获异常
自定义异常
异常堆栈

# 异常概述

异常指不期而至的各种状况，它在程序运行的过程中发生。作为开发者，我们都希望自己写的代码永远都不会出现 bug，然而现实告诉我们并没有这样的情景。如果用户在程序的使用过程中因为一些原因造成他的数据丢失，这个用户就可能不会再使用该程序了。所以，对于程序的错误以及外部环境能够对用户造成的影响，我们应当及时报告并且以适当的方式来处理这个错误。

之所以要处理异常，也是为了增强程序的鲁棒性 (opens new window)。

异常都是从 Throwable 类派生出来的，而 Throwable 类是直接从 Object 类继承而来。你可以在 Java SE 官方 API 文档中获取更多关于它们的知识。

Throwable是类，Exception和Error都继承了该类所以在捕捉的时候，也可以使用Throwable进行捕捉异常分Error和Exception Exception里又分运行时异常和可查异常。

# java异常处理机制

java中所有错误的超类为:Throwable。其下有两个子类:Error和Exception
Error的子类描述的都是系统错误，比如虚拟机内存溢出等。
Exception的子类描述的都是程序错误，比如空指针，下表越界等。
通常我们程序中处理的异常都是Exception。

Throwable

# 异常分类

异常通常有四类：

Error：系统内部错误，这类错误由系统进行处理，程序本身无需捕获处理。
Exception：可以处理的异常。
RuntimeException：可以捕获，也可以不捕获的异常。
继承 Exception 的其他类：必须捕获，通常在 API 文档中会说明这些方法抛出哪些异常。

# Java异常可以分为可检测异常，非检测异常

可检测异常：可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译
非检测异常：非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常
RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。

平时主要关注的异常是 Exception 下的异常，而 Exception 异常下又主要分为两大类异常，一个是派生于 RuntimeExcption 的异常，一个是除了 RuntimeExcption 体系之外的其他异常。

RuntimeExcption异常（运行时异常）通常有以下几种：

错误的类型转换
- ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常
- NumberFormatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
数组访问越界ArrayIndexOutOfBoundsException：当使用的数组下标超出数组允许范围时，抛出该异常
访问 null 指针NullPointerException：当应用程序试图在需要对象的地方使用 null 时，抛出该异常
算术异常IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数

一般来说，RuntimeException 都是代码逻辑出现问题。

非RuntimeException（受检异常，Checked Exception）一般有：

打开一个不存在的文件
没有找到具有指定名称的类
操作文件异常

受检异常是编译器要求必须处理的异常，必须使用 try catch 处理，或者使用 throw 抛出，交给上层调用者处理。

# 异常中常用的方法

package exception;

/**
 * 异常常用的方法
 */
public class ExceptionAPIDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        try {
            String str = "abc";
            System.out.println(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            System.out.println("处理异常的操作...");
            e.printStackTrace();//将错误信息输出到控制台
            System.out.println("message:"+e.getMessage());//获取错误消息
        }
        System.out.println("程序结束了...");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 声明及抛出

# throw 抛出异常

当程序运行时数据出现错误或者我们不希望发生的情况出现的话，可以通过抛出异常来处理。

异常抛出语法：

throw new 异常类();

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常:

1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。

package exception;

/**
 * 使用当前类测试异常的抛出
 */
public class Person {
    private int age;//年龄

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0||age>100){
            //当未达到业务要求时可以对外抛出异常
            throw new RuntimeException("年龄不合法!");
        }
        this.age = age;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package exception;

/**
 * throw关键字，用来对外主动抛出一个异常。
 * 通常下面两种情况我们主动对外抛出异常:
 * 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 * 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
 */
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
        System.out.println("此人年龄:"+p.getAge());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# throws 声明异常

throws 用于声明异常，表示该方法可能会抛出的异常。如果声明的异常中包括 checked 异常（受检异常），那么调用者必须捕获处理该异常或者使用 throws 继续向上抛出。throws 位于方法体前，多个异常之间使用 , 分割。

当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。

package exception;

/**
 * 使用当前类测试异常的抛出
 */
public class Person {
    private int age;//年龄

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception {
        if(age<0||age>100){
            //当未达到业务要求时可以对外抛出异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException.其他异常抛出时要在方法上使用throws通知调用者
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过。处理手段有两种:

使用try-catch捕获并处理这个异常
在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。具体选取那种取决于异常处理的责任问题。

package exception;

/**
 * throw关键字，用来对外主动抛出一个异常。
 * 通常下面两种情况我们主动对外抛出异常:
 * 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 * 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
 */
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        /*
            当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理
            这个异常，否则编译不通过。
            处理手段有两种:
            1:使用try-catch捕获并处理这个异常
            2:在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给
              调用者解决。
            具体选取那种取决于异常处理的责任问题。
         */
        try {
            p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("此人年龄:"+p.getAge());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

注意，永远不应当在main方法上使用throws!!

# throw和throws的区别

throws与throw这两个关键字接近，不过意义不一样，有如下区别：

throws 出现在方法声明上，而throw通常都出现在方法体内。
throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某个异常对象。

# 含有throws的方法被子类重写时的规则

package exception;

import java.awt.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

/**
 * 子类在重写超类含有throws声明的异常抛出方法时对throws的重写规则
 */
public class ThrowsDemo {
    public void dosome()throws IOException, AWTException {
    }
}

class SubClass extends ThrowsDemo{
//    public void dosome()throws IOException, AWTException {
//    }

    //可以不再抛出任何异常
//    public void dosome(){
//    }

    //可以仅抛出超类方法抛出异常的部分
//    public void dosome()throws IOException {
//    }

    //允许抛出超类方法抛出异常的子类型异常
//    public void dosome()throws FileNotFoundException {
//    }

    //不允许抛出额外异常(超类方法没有抛出的，且不与超类方法抛出异常存在继承关系的)
//    public void dosome()throws SQLException {
//    }

    //不允许抛出超类方法抛出异常的超类型异常
//    public void dosome()throws Exception {
//    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 捕获异常

# `try` `catch`

将可能抛出FileNotFoundException 文件不存在异常的代码放在try里
如果文件存在，就会顺序往下执行，并且不执行catch块中的代码
如果文件不存在，try 里的代码会立即终止，程序流程会运行到对应的catch块中
e.printStackTrace();会打印出方法的调用痕迹.

通常抛出异常后，还需要将异常捕获。使用 try 和 catch 语句块来捕获异常，有时候还会用到 finally。

无论是否出现异常，finally中的代码都会被执行

对于上述三个关键词所构成的语句块，try 语句块是必不可少的，catch 和 finally 语句块可以根据情况选择其一或者全选。你可以把可能发生错误或出现问题的语句放到 try 语句块中，将异常发生后要执行的语句放到 catch 语句块中，而 finally 语句块里面放置的语句，不管异常是否发生，它们都会被执行。

你可能想说，那我把所有有关的代码都放到 try 语句块中不就妥当了吗？可是你需要知道，捕获异常对于系统而言，其开销非常大，所以应尽量减少该语句块中放置的语句。

public class CatchException {
    public static void main(String[] args) {
        try {
            // 下面定义了一个try语句块

            System.out.println("I am try block.");

            Class<?> tempClass = Class.forName("");
            // 声明一个空的Class对象用于引发“类未发现异常”
            System.out.println("Bye! Try block.");

        } catch (ClassNotFoundException e) {
            // 下面定义了一个catch语句块
            System.out.println("I am catch block.");

            e.printStackTrace();
            //printStackTrace()的意义在于在命令行打印异常信息在程序中出错的位置及原因

            System.out.println("Goodbye! Catch block.");

        } finally {
            // 下面定义了一个finally语句块
            System.out.println("I am finally block.");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package exception;

/**
 * java中有完善的异常处理机制。格式为:
 * try{
 *     代码片段
 * }catch(XXXException e){
 *     处理try中出现的XXXException的代码
 * }
 *
 */
public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了!");
        try {
//            String str = null;
//            String str = "a";
            String str = "aa";
            //当JVM执行代码出现错误时，就会实例化对应问题的异常实例，并设置出错位置后将其抛出
            System.out.println(str.length());//当str为null时，会抛出空指针异常
            System.out.println(str.charAt(1));//当下标超范围时会抛出下标越界异常
            System.out.println(Integer.parseInt(str));
            //try语句块中报错代码以下的内容均不执行!
            System.out.println("!!!!!!!!!");
        }catch(NullPointerException e){
            //定义try中出现空指针异常后的解决办法
            System.out.println("出现了空指针!");
        //catch可以定义多个，针对try中不同异常有不同处理方式时可以分别捕获并处理
        }catch(StringIndexOutOfBoundsException e){
            System.out.println("出现了字符串下标越界了!");
        /*
            通常以下情况我们可以捕获一个超类异常:
            1:当try中出现了几种不同的异常，但是它们的解决办法相同时，我们可以catch
               它们共同的超类异常即可。
               catch(NullPointerException | StringIndexOutOfBoundsException e)
            2:在最后一个catch处捕获Exception可以避免因为一个未处理的异常导致程序
              中断。
         */
        }catch(Exception e){
            System.out.println("反正就是出了个错!");
        }
        System.out.println("程序结束了!");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# 捕获多个异常

在一段代码中，可能会由于各种原因抛出多种不同的异常，而对于不同的异常，我们希望用不同的方式来处理它们，而不是笼统的使用同一个方式处理，在这种情况下，可以使用异常匹配，当匹配到对应的异常后，后面的异常将不再进行匹配。

import java.io.FileInputStream;
import java.io.FileNotFoundException;//FileNotFoundException是Exception的子类，使用Exception也可以catch住FileNotFoundException

public class MultipleCapturesDemo {
    public static void main(String[] args) {
        try {
            new FileInputStream("");
        } catch (FileNotFoundException e) {//分别进行catch
            System.out.println("IO 异常");
        } catch (Exception e) {
            System.out.println("发生异常");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

在处理异常时，并不要求抛出的异常同 catch 所声明的异常完全匹配，子类的对象也可以匹配父类的处理程序。比如异常 A 继承于异常 B，那么在处理多个异常时，一定要将异常 A 放在异常 B 之前捕获，如果将异常 B 放在异常 A 之前，那么将永远匹配到异常 B，异常 A 将永远不可能执行，并且编译器将会报错.

# 异常处理机制中的finally

finally块定义在异常处理机制中的最后一块。它可以直接跟在try之后，或者最后一个catch之后。
finally可以保证只要程序执行到了try语句块中，无论try语句块中的代码是否出现异常，最终finally都必定执行。
finally通常用来做释放资源这类操作。

package exception;

/**
 * 异常处理机制中的finally块
 * finally块定义在异常处理机制中的最后一块。它可以直接跟在try之后，或者最后一个catch之后。
 *
 * finally可以保证只要程序执行到了try语句块中，无论try语句块中的代码是否出现异常，最终
 *  finally都必定执行。
 *
 * finally通常用来做释放资源这类操作。
 */
public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        try{
            String line = "abc";
//            String line = null;
            System.out.println(line.length());
            return;
        }catch(Exception e){
            System.out.println("出错了!");
        }finally{
            System.out.println("finally中的代码执行了!");
        }
        System.out.println("程序结束了!");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# IO操作时的异常处理机制应用

package exception;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * IO操作时的异常处理机制应用
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("fos.dat");
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();//向控制台输出当前异常的错误信息
        } finally {
            try {
                if (fos!=null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 自动关闭特性

JDK7之后，java提供了一个新的特性:自动关闭。旨在IO操作中可以更简洁的使用异常处理机制完成最后的close操作。

语法:
try(
   	定义需要在finally中调用close()方法关闭的对象.
){
    IO操作
}catch(XXXException e){
    ...
}

1
2
3
4
5
6
7
8

上述语法中可在try的"()"中定义的并初始化的对象必须实现了java.io.AutoCloseable接口,否则编译不通过.

public class AutocloseableDemo {
    public static void main(String[] args) {
        try(
                FileOutputStream fos = new FileOutputStream("fos.dat");//只要是流都可以
        ){
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();//向控制台输出当前异常的错误信息
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

上述代码是编译器认可的，而不是虚拟机。编译器在编译上述代码后会在编译后的class文件中改回成FinallyDemo2案例的代码样子(上次课最后的案例)。

# 面试题

package exception;

/**
 * Finally面试题
 */
public class FinallyDemo3 {
    public static void main(String[] args) {
        //下面的输出结果是:?,?,?
        System.out.println(test("0")+","+test(null)+","+test(""));
        //3,3,3
    }
    public static int test(String str){
        try{
            System.out.println("执行了一次test方法，参数str:"+str);
            return str.charAt(0)-'0';
        }catch(NullPointerException e){
            System.out.println("出现了空指针!");
            return 1;
        }catch(Exception e){
            System.out.println("出现了其他异常");
            return 2;
        }finally{
            System.out.println("finally的代码执行了!");
            return 3;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 自定义异常

尽管 Java SE 的 API 已经为我们提供了数十种异常类，然而在实际的开发过程中，你仍然可能遇到未知的异常情况。此时，你就需要对异常类进行自定义。

自定义一个异常类非常简单，只需要让它继承 Exception 或其子类就行。在自定义异常类的时候，建议同时提供无参构造方法和带字符串参数的构造方法，后者可以为你在调试时提供更加详细的信息。

// MyAriException.java
public class MyAriException extends ArithmeticException {
    //自定义异常类，该类继承自ArithmeticException

    public MyAriException() {

    }
    //实现默认的无参构造方法

    public MyAriException(String msg) {
        super(msg);
    }
    //实现可以自定义输出信息的构造方法，将待输出信息作为参数传入即可
}


// ExceptionTest.java
import java.util.Arrays;

public class ExceptionTest {
    public static void main(String[] args) {
        int[] array = new int[5];
        //声明一个长度为5的数组

        Arrays.fill(array, 5);
        //将数组中的所有元素赋值为5

        for (int i = 4; i > -1; i--) {
            //使用for循环逆序遍历整个数组，i每次递减

            if (i == 0) {
            // 如果i除以了0，就使用带异常信息的构造方法抛出异常

                throw new MyAriException("There is an exception occured.");
            }

            System.out.println("array[" + i + "] / " + i + " = " + array[i] / i);
            // 如果i没有除以0，就输出此结果
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

自定义异常通常用来定义那些业务上的异常问题。

定义自定义异常需要注意以下问题:

异常的类名要做到见名知义
需要是Exception的子类
提供超类异常提供的所有种类构造器

package exception;

/**
 * 自定义异常
 * 自定义异常通常用来定义那些业务上的异常问题。
 * 定义自定义异常需要注意以下问题:
 * 1:异常的类名要做到见名知义
 * 2:需要是Exception的子类
 * 3:提供超类异常提供的所有种类构造器
 *
 * 年龄不合法异常，当年龄超过了允许范围时会抛出该异常。
 */
public class IllegalAgeException extends Exception{
    public IllegalAgeException() {
    }

    public IllegalAgeException(String message) {
        super(message);
    }

    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public IllegalAgeException(Throwable cause) {
        super(cause);
    }

    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package exception;

/**
 * 使用当前类测试异常的抛出
 */
public class Person {
    private int age;//年龄

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws IllegalAgeException {
        if(age<0||age>100){
            //当未达到业务要求时可以对外抛出异常
//            throw new RuntimeException("年龄不合法!");
            //除了RuntimeException.其他异常抛出时要在方法上使用throws通知调用者
            throw new IllegalAgeException("年龄不合法!");//业务问题抛出自定义异常
        }
        this.age = age;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package exception;

/**
 * throw关键字，用来对外主动抛出一个异常。
 * 通常下面两种情况我们主动对外抛出异常:
 * 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 * 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
 */
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        /*
            当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理
            这个异常，否则编译不通过。
            处理手段有两种:
            1:使用try-catch捕获并处理这个异常
            2:在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给
              调用者解决。
            具体选取那种取决于异常处理的责任问题。
         */

        try {
            p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
        } catch (IllegalAgeException e) {
            e.printStackTrace();
        }

        System.out.println("此人年龄:"+p.getAge());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 异常堆栈

当异常抛出后，我们可以通过异常堆栈追踪程序的运行轨迹，以便我们更好的 DEBUG。

public class ExceptionStackTrace {
    private static void method1() {
        method2();
    }

    private static void method2() {
        throw new NullPointerException();
    }
    public static void main(String[] args) {
        try {
            method1();
        } catch (Exception e) {
            //打印堆栈轨迹
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

通过上面的异常堆栈轨迹，在对比我们方法的调用过程，可以得出异常信息中首先打印的是距离抛出异常最近的语句，接着是调用该方法的方法，一直到最开始被调用的方法。从下往上看，就可以得出程序运行的轨迹。

← 函数式编程网络编程 →

# 异常

# 异常概述

# java异常处理机制

# 异常分类

# Java异常可以分为可检测异常，非检测异常

# 异常中常用的方法

# 声明及抛出

# throw 抛出异常

# throws 声明异常

# throw和throws的区别

# 含有throws的方法被子类重写时的规则

# 捕获异常

# try catch

# 捕获多个异常

# 异常处理机制中的finally

# IO操作时的异常处理机制应用

# 自动关闭特性

# 面试题

# 自定义异常

# 异常堆栈

# `try` `catch`