你尽管try我尽量catch，二当家的带你搞明白java的异常机制

2022-02-01 12:42:47

前言

java的异常机制你都懂了么？二当家的一文带你深入浅出，理解透彻。

程序异常

异常本质上是程序上的错误，错误在我们编写程序的过程中会经常发生，包括编译期间和运行期间的错误。

编译期间的错误：
通常都是语法错误，这个不是重点，毕竟运行不了的程序不会发生什么大事。
运行期间的错误：
有的错误程序没办法管，有的错误程序不应该管，还有的错误程序必须管。运行时的错误如果没有处理好，业务上是会出问题的哦，很可能是一发而不可收拾呢。

运行期间的错误怎么管

发生错误，我们首先得知道，怎么知道呢？java里用try-catch语句处理运行期间的错误，用关键字try去执行可能发生错误的代码，然后用关键字catch去捕获程序运行期间发生的错误。

public class Test {

    private static void printDiv(int dividend, int divisor) {
        System.out.println(dividend + " / " + divisor + " = " + (dividend / divisor));
    }

    public static void main(String[] args) {
        printDiv(10, 5);
        printDiv(10, 0);
        printDiv(10, 2);
    }
}

上面的代码分别输出 10 / 5，10 / 0 和 10 / 2 的结果。但是运行结果显示，在执行 10 / 0 时程序就异常退出了，0是不能作为除数的。

接下来我们修改下代码，让我们的程序可以兼容异常情况。

public class Test {

    private static void printDiv(int dividend, int divisor) {
        try {
            System.out.println(dividend + " / " + divisor + " = " + (dividend / divisor));
        } catch(ArithmeticException e) {
            System.out.println(dividend + " / " + divisor + " 发生错误：" + e.getMessage());
        }
    }

    public static void main(String[] args) {
        printDiv(10, 5);
        printDiv(10, 0);
        printDiv(10, 2);
    }
}

在使用try-catch语法处理了错误以后，可以看到，当程序执行到发生错误的代码行，就会跳转到catch的块里继续执行，程序没有再异常退出了。

catch可以捕获哪些错误

cache捕获的都是Throwable类和它的子类，Throwable下有两个大类Error和Exception。其他的错误或异常都应该继承自他们俩。

Error：
Error是系统级别的错误，不该由应用程序捕获处理，应该交给系统或者框架来捕获处理。
Exception：
Exception是程序级别的错误，应该由程序模块去捕获处理。

如何发起一个异常

我们自己写的代码也会有异常情况，如何发起一个异常情况呢？可以使用throw关键字。

public class Test {
    private static void someMethod() {
        // 使用throw关键字抛出异常
        throw new RuntimeException("运行中发生异常");
    }

    public static void main(String[] args) {
        someMethod();
        System.out.println("主方法执行完毕");
    }
}

我们也可以抛出Error和它的子类，但是通常我们应该抛出Exception和它的子类。之前已经讲过他们的区别。

public class Test {
    private static void someMethod() {
        // 使用throw关键字抛出错误
        throw new Error("运行中发生错误");
    }

    public static void main(String[] args) {
        someMethod();
        System.out.println("主方法执行完毕");
    }
}

我们抛出另外一种异常，竟然编译就不通过了。

import java.sql.SQLException;

public class Test {
    private static void someMethod() {
        // 使用throw关键字抛出异常
        throw new SQLException("运行中发生异常");
    }

    public static void main(String[] args) {
        someMethod();
        System.out.println("主方法执行完毕");
    }
}

可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）

可查的异常（checked exceptions）
除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。Java编译器会检查这种异常，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
不可查的异常（unchecked exceptions）
不可查异常（编译器不要求强制处置的异常）：包括运行时异常（RuntimeException与其子类）和错误（Error）。

原来SQLException属于可查的异常（checked exceptions），我们必须用try-catch捕获，或者声明抛出，捕获我们已经会了，怎么声明抛出呢？可以使用throws关键字。

import java.sql.SQLException;

public class Test {
    private static void someMethod() throws SQLException {
        // 使用throw关键字抛出异常
        throw new SQLException("运行中发生异常");
    }

    public static void main(String[] args) throws SQLException {
        someMethod();
        System.out.println("主方法执行完毕");
    }
}

这样就可以编译通过了呢。

自定义异常

java已经内置了很多错误和异常类型，我就不罗列了，很容易查到，当内置的异常类型不能正确表达我们的错误时，我们也可以自定义错误和异常类型，只需要继承Error或者Exception。

public class Test {
    /**
     * 自定义的异常类型
     */
    static class MyRuntimeException extends RuntimeException {
        public MyRuntimeException(String message) {
            super(message);
        }
    }

    private static void someMethod() {
        // 使用throw关键字抛出异常
        throw new MyRuntimeException("运行中发生异常");
    }

    public static void main(String[] args) {
        someMethod();
        System.out.println("主方法执行完毕");
    }
}

try的姿势

try的一般姿势有三种

public class Test {
    public static void main(String[] args) {
        // 姿势一
        try {
            // 有可能抛出异常的部分
        } catch (Exception e) {
            // 对异常的处理
        }

        // 姿势二
        try {
            // 有可能抛出异常的部分
        } finally {
            // 不管是否发生异常，都要执行的部分
        }

        // 姿势三
        try {
            // 有可能抛出异常的部分
        } catch (Exception e) {
            // 对异常的处理
        } finally {
            // 不管是否发生异常，都要执行的部分
        }
    }
}

上面的方式都是针对错误进行统一的处理，如果一段代码可能发生多种错误，我要针对某种错误进行特殊的处理怎么办？

import java.io.IOException;

public class Test {

    /**
     * 将结果写入文件
     * @param ret
     * @throws IOException
     */
    private static void writeFile(int ret) throws IOException {
        // 我假装将结果写入文件，其实没那么干，但是那是我的事，调用的人请保密
        throw new IOException("磁盘满了啦");
    }

    private static void printDiv(int dividend, int divisor) {
        try {
            int ret = dividend / divisor;
            System.out.println(dividend + " / " + divisor + " = " + ret);
            writeFile(ret);
        } catch(Exception e) {
            if (e instanceof IOException) {
                System.out.println(dividend + " / " + divisor + " 发生IO错误：" + e.getMessage());
            } else {
                System.out.println(dividend + " / " + divisor + " 发生错误：" + e.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        printDiv(10, 5);
        printDiv(10, 0);
        printDiv(10, 2);
    }
}

上面的代码达到了想要的效果，然而有点傻，其实java已经有语法直接处理这种情况。下面才是正确的方式哦，执行结果和上面的一样。

import java.io.IOException;

public class Test {

    /**
     * 将结果写入文件
     * @param ret
     * @throws IOException
     */
    private static void writeFile(int ret) throws IOException {
        // 我假装将结果写入文件，其实没那么干，但是那是我的事，调用的人请保密
        throw new IOException("磁盘满了啦");
    }

    private static void printDiv(int dividend, int divisor) {
        try {
            int ret = dividend / divisor;
            System.out.println(dividend + " / " + divisor + " = " + ret);
            writeFile(ret);
        } catch (IOException e) {
            System.out.println(dividend + " / " + divisor + " 发生IO错误：" + e.getMessage());
        } catch(Exception e) {
            System.out.println(dividend + " / " + divisor + " 发生错误：" + e.getMessage());
        }
    }

    public static void main(String[] args) {
        printDiv(10, 5);
        printDiv(10, 0);
        printDiv(10, 2);
    }
}

有一点要注意，如果我们需要同时catch父子类异常，那么子类一定要先catch，因为java是按照代码顺序匹配的，如果把父类的catch块写在前面，那子类的catch块就永远不会运行到。

如果我要对发生的多种异常进行分组处理，其中几种用第一种处理方式，另外几种用第二种处理方式，其他的用第三种处理方式统一处理呢？我们当然可以cache多次，然后几个cache块写一样的内容，但是那样依然很傻。下面才是正确的方式。

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.WriteAbortedException;

public class Test {

    /**
     * 将结果写入文件
     * @param ret
     * @throws IOException
     */
    private static void writeFile(int ret) throws FileNotFoundException, WriteAbortedException {
        // 我假装将结果写入文件，其实没那么干，但是那是我的事，调用的人请保密
        int i = (int) (Math.random() * 3);

        switch (i) {
            case 0:
                throw new FileNotFoundException("文件不存在");
            case 1:
                throw new FileNotFoundException("文件写入被中断");
            case 2:
                throw new FileNotFoundException("磁盘满了啦");
        }
    }

    private static void printDiv(int dividend, int divisor) {
        try {
            int ret = dividend / divisor;
            System.out.println(dividend + " / " + divisor + " = " + ret);
            writeFile(ret);
        } catch (FileNotFoundException | WriteAbortedException e) {
            System.out.println(dividend + " / " + divisor + " 文件写入发生错误：" + e.getMessage());
        } catch (IOException e) {
            System.out.println(dividend + " / " + divisor + " 发生IO错误：" + e.getMessage());
        } catch(Exception e) {
            System.out.println(dividend + " / " + divisor + " 发生错误：" + e.getMessage());
        }
    }

    public static void main(String[] args) {
        printDiv(10, 5);
        printDiv(10, 0);
        printDiv(10, 2);
    }
}

什么情况需要用到finally块呢

先看下面一段代码

import java.io.FileWriter;
import java.io.IOException;

public class Test {

    /**
     * 写入文件
     * @param text
     * @throws IOException
     */
    private static boolean writeFile(String text) throws IOException {
        try {
            System.out.println("申请使用资源");
            FileWriter fw = new FileWriter("test.txt");
            // 在这之后可能发生异常
            fw.write(text);
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            // 这里关闭流资源，但是可能在这之前发生异常
            System.out.println("关闭资源");
            fw.close();
            return true;
        } catch (Exception e) {
            System.out.println("处理异常：" + e.getMessage());
            return false;
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

像IO流等系统资源，在从系统申请用完之后，需要手动释放，否则就会发生泄露。上面的代码，如果在关闭资源之前，发生了异常，程序就会跳到catch块继续执行，那关闭资源的代码就永远不会执行，直到程序退出。该怎么办呢？这时候就需要finally了。

import java.io.FileWriter;
import java.io.IOException;

public class Test {

    /**
     * 写入文件
     * @param text
     * @throws IOException
     */
    private static boolean writeFile(String text) throws IOException {
        FileWriter fw = null;
        try {
            System.out.println("申请使用资源");
            fw = new FileWriter("test.txt");
            // 在这之后可能发生异常
            fw.write(text);
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            return true;
        } catch (Exception e) {
            System.out.println("处理异常：" + e.getMessage());
            return false;
        } finally {
            if (fw != null) {
                System.out.println("关闭资源");
                fw.close();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

上面的代码做了修改，将关闭资源的代码放到了finally块内，无论try是否发生异常，finally内的代码都会执行。不光是关闭资源，任何无论是否发生异常都应该执行的逻辑都可以放在finally块内。

另外注意一点，catch块也可能发生异常，但是finally块内的代码还是会执行。

import java.io.FileWriter;
import java.io.IOException;

public class Test {

    /**
     * 写入文件
     * @param text
     * @throws IOException
     */
    private static boolean writeFile(String text) throws IOException {
        FileWriter fw = null;
        try {
            System.out.println("申请使用资源");
            fw = new FileWriter("test.txt");
            // 在这之后可能发生异常
            fw.write(text);
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            return true;
        } catch (Exception e) {
            System.out.println("处理异常：" + e.getMessage());
            throw new RuntimeException("处理异常情况时发生异常");
//            return false;
        } finally {
            if (fw != null) {
                System.out.println("关闭资源");
                fw.close();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

但是如果finally块发生异常，后面的代码就不会继续执行了。

import java.io.FileWriter;
import java.io.IOException;

public class Test {

    /**
     * 写入文件
     * @param text
     * @throws IOException
     */
    private static boolean writeFile(String text) throws IOException {
        FileWriter fw = null;
        try {
            System.out.println("申请使用资源");
            fw = new FileWriter("test.txt");
            // 在这之后可能发生异常
            fw.write(text);
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            return true;
        } catch (Exception e) {
            System.out.println("处理异常：" + e.getMessage());
            return false;
        } finally {
            if (true) {
                throw new RuntimeException("finally块发生异常");
            }
            if (fw != null) {
                System.out.println("关闭资源");
                fw.close();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

finally块的代码通常是必须执行的，所以要catch掉可能的异常，try-catch语法是可以嵌套的哦。

import java.io.FileWriter;
import java.io.IOException;

public class Test {

    /**
     * 写入文件
     * @param text
     * @throws IOException
     */
    private static boolean writeFile(String text) throws IOException {
        FileWriter fw = null;
        try {
            System.out.println("申请使用资源");
            fw = new FileWriter("test.txt");
            // 在这之后可能发生异常
            fw.write(text);
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            return true;
        } catch (Exception e) {
            System.out.println("处理异常：" + e.getMessage());
            return false;
        } finally {
            try {
                throw new RuntimeException("finally块发生异常");
            } finally {
                if (fw != null) {
                    System.out.println("关闭资源");
                    fw.close();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

try-with-resources语法

像IO流这种有限系统资源的情况有很多，都大同小异，都是需要在最终使用完去手动调用关闭。每次都写模板一般的代码，有点傻，重复劳动，而且为了finally块和try块都可以访问那个变量，就必须声明在try-catch之外，这就导致finally块后面的代码还可以访问那个变量，这是不合理的。所以后来java有了新的语法来处理这种情况。实现AutoCloseable接口的类，都可以实现自动关闭。

import java.io.IOException;

public class Test {
    static class SomeResource implements AutoCloseable {
        public void use() {
            System.out.println("使用资源");
        }

        @Override
        public void close() {
            System.out.println("关闭资源");
        }
    }

    /**
     * 写入文件
     * @param text
     */
    private static boolean writeFile(String text) {
        try (SomeResource resource = new SomeResource();) {
            resource.use();
            // 在这之后可能发生异常
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            return true;
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

可以看到上面的代码使用资源后，并没有手动调用关闭方法，关闭方法是被自动调用的。我们之前使用的FileWriter已经实现了AutoCloseable接口，所以也可以自动关闭了。

可以在一个块里使用多个可自动关闭资源，顺序是初始化的逆序。

import java.io.IOException;

public class Test {
    static class SomeResource implements AutoCloseable {
        private final String name;

        SomeResource(String name) {
            this.name = name;
            System.out.println("初始化资源：" + name);
        }

        public void use() {
            System.out.println("使用资源：" + name);
        }

        @Override
        public void close() {
            System.out.println("关闭资源：" + name);
        }
    }

    /**
     * 写入文件
     *
     * @param text
     */
    private static boolean writeFile(String text) {
        try (
                SomeResource resource1 = new SomeResource("测试资源1");
                SomeResource resource2 = new SomeResource("测试资源2");
                SomeResource resource3 = new SomeResource("测试资源3");
        ) {
            resource2.use();
            resource1.use();
            resource3.use();
            // 在这之后可能发生异常
            if (true) {
                throw new RuntimeException("运行中发生的异常");
            }
            return true;
        }
    }

    public static void main(String[] args) throws IOException {
        writeFile("test");
    }
}

尾声

二当家的已经力求写的全面，如有不尽或者不准确的地方还请小伙伴们多见谅，欢迎评论区讨论。另外请赏个三连吧，多谢。

非常感谢你阅读本文~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由二当家的白帽子：https://developer.aliyun.com/profile/sqd6avc7qgj7y 博客原创~

码农公寓

前言