“好啊，二哥，我洗耳恭听。”三妹也微微一笑，欣然接受。

    “好，那哥就不废话了。开整。”

    1）尽量不要捕获 RuntimeException

    阿里出品的嵩山版 Java 开发手册上这样规定：

    正例：

    反例：

    2.   obj.method(); 
    3. } catch (NullPointerException e) {
    4.   //...
    5. }

    “哦，那如果有些异常预检查不出来呢？”三妹问。

    “的确会存在这样的情况，比如说 NumberFormatException，虽然也属于 RuntimeException，但没办法预检查，所以还是应该用 catch 捕获处理。”我说。

    2）尽量使用 try-with-resource 来关闭资源

    当需要关闭资源时，尽量不要使用 try-catch-finally，禁止在 try 块中直接关闭资源。

    反例：

    1. public void doNotCloseResourceInTry() {
    2.     FileInputStream inputStream = null;
    3.     try {
    4.         File file = new File("./tmp.txt");
    5.         inputStream = new FileInputStream(file);
    6.         inputStream.close();
    7.     } catch (FileNotFoundException e) {
    8.         log.error(e);
    9.     } catch (IOException e) {
    10.         log.error(e);
    11.     }
    12. }

    “为什么呢？”三妹问。

    “除非资源没有实现 AutoCloseable 接口。”我补充道。

    “那这种情况下怎么办呢？”三妹问。

    “就在 finally 块关闭流。”我说。

    1. public void closeResourceInFinally() {
    2.     FileInputStream inputStream = null;
    3.         File file = new File("./tmp.txt");
    4.         inputStream = new FileInputStream(file);
    5.     } catch (FileNotFoundException e) {
    6.         log.error(e);
    7.     } finally {
    8.         if (inputStream != null) {
    9.             try {
    10.                 inputStream.close();
    11.             } catch (IOException e) {
    12.                 log.error(e);
    13.             }
    14.         }
    15.     }
    16. }

    3）不要捕获 Throwable

    Throwable 是 exception 和 error 的父类，如果在 catch 子句中捕获了 Throwable，很可能把超出程序处理能力之外的错误也捕获了。

    1. public void doNotCatchThrowable() {
    2.     try {
    3.     } catch (Throwable t) {
    4.         // 不要这样做
    5.     }

    “到底为什么啊？”三妹问。

    “因为有些 error 是不需要程序来处理，程序可能也处理不了，比如说 OutOfMemoryError 或者 StackOverflowError，前者是因为 Java 虚拟机无法申请到足够的内存空间时出现的非正常的错误，后者是因为线程申请的栈深度超过了允许的最大深度出现的非正常错误，如果捕获了，就掩盖了程序应该被发现的严重错误。”我说。

    “打个比方，一匹马只能拉一车厢的货物，拉两车厢可能就挂了，但一 catch，就发现不了问题了。”我补充道。

    4）不要省略异常信息的记录

    很多时候，由于疏忽大意，开发者很容易捕获了异常却没有记录异常信息，导致程序上线后真的出现了问题却没有记录可查。

    应该把错误信息记录下来。

    1. public void logAnException() {
    2.     try {
    3.     } catch (NumberFormatException e) {
    4.         log.error("哦，错误竟然发生了: " + e);
    5.     }
    6. }

    5）不要记录了异常又抛出了异常

    这纯属画蛇添足，并且容易造成错误信息的混乱。

    1. try {
    2. } catch (NumberFormatException e) {
    3.     log.error(e);
    4.     throw e;
    5. }

    要抛出就抛出，不要记录，记录了又抛出，等于多此一举。

    反例：

    这种也是一样的道理，既然已经捕获了，就不要在方法签名上抛出了。

    6）不要在 finally 块中使用 return

    阿里出品的嵩山版 Java 开发手册上这样规定：

    try 块中的 return 语句执行成功后，并不会马上返回，而是继续执行 finally 块中的语句，如果 finally 块中也存在 return 语句，那么 try 块中的 return 就将被覆盖。

    反例：

    1. private int x = 0;
    2. public int checkReturn() {
    3.     try {
    4.         return ++x;
    5.     } finally {
    6.         return ++x;
    7.     }
    8. }

    “哦，确实啊，try 块中 x 返回的值为 1，到了 finally 块中就返回 2 了。”三妹说。

    “是这样的。”我点点头。

    “好了，三妹，关于异常处理实践就先讲这 6 条吧，实际开发中你还会碰到其他的一些坑，自己踩一踩可能印象更深刻一些。”我说。

    “那万一到时候我工作后被领导骂了怎么办？”三妹委屈地说。

    “新人嘛，总要写几个 bug 才能对得起新人这个称号嘛。”我轻描淡写地说。

    “好吧。”三妹无奈地叹了口气。