2158 2018-04-05 2020-06-25

前言：异常是Java语言区别于其他语言的又一特色。

一、Throwable类

1、概述

安全、健壮的程序设计语言应当引入有效的异常处理机制。在Java中，Java提供一个以Throwable类为基类的一系列异常类和错误类。如下图

从图可以看出，Throwable有两个直接子类：Error和Exception。其中

• Error类称为错误类，代表程序出现的错误，如程序运行时系统内部错误或资源耗尽等。这种错误是不能通修改程序代码来恢复的。
• Exception类称为异常类，代表程序出现的异常。这种异常可以通过完善程序代码来避免。

2、Exception类

其中Exception类又分为运行异常类和非运行异常类。其中

• 运行异常类指RuntimeException类及其子类，这些异常的产生一般是由程序员的编译错误引起的，完全可以通过改进程序避免。因此，Java编译器对此类异常不进行检查，即不需要显式的进行捕获。
• 非运行异常类包括RuntimeException外的Exception其他子类，又称为编译异常，这类异常的特点是只有运行环境正常，程序是能够正常运行的。因此，Java编译器要求Java程序必须捕获或处理所有非运行异常。

常见的运行异常类如下：

异常类	异常类描述	异常类别
ArithmeticException	算术错误，如除数为0	运行异常
ArrayIndexOutOfBoundsException	数组越界使用	运行异常
NullPointerException	引用空对象	运行异常
IllegalArgumentException	不合法参数	运行异常
NumberFormatException	数字格式不对，如将“abc”转为数字	运行异常

常见的非运行异常类如下：

异常类	异常类描述	异常类别
ClassNotFoundException	未找到欲装载的类	非运行异常
FileNotFoundException	未找到指定的文件或目录	非运行异常
IOException	IO输入、输出错误	非运行异常

3、常用方法

Throwable类提供几个常用的方法，用于显示与异常相关的信息。

方法声明	功能描述
Throwable getCause（）	返回抛出异常的原因。如果 cause 不存在或未知，则返回 null
Throwable initCause(Throwable cause)	初始化cause
String getMessage（）	返回异常的消息信息
void pringStackTrace（）	对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值

更多方法说明可以参考Throwable的API。

4、仿Spring的嵌套异常

下面是仿照Spring嵌套异常的代码

static class GrandFather extends RuntimeException {
    GrandFather(String msg, Throwable ex) {
        super(msg);
        initCause(ex);
    }
    protected void print() {
        System.out.print("grandfather exception happen nested is :");
        Throwable cause = this.getCause();
        while (cause != null) {
            if (cause instanceof GrandFather) {
                ((GrandFather) cause).print();
            }
            cause = cause.getCause();
        }
    }
}

static class Father extends GrandFather {
    public Father(String msg, Throwable ex) {
        super(msg, ex);
    }
    @Override
    protected void print() {
        System.out.print("father exception happen nested is :");
    }
}

static class Son extends Father {
    public Son(String msg, Throwable ex) {
        super(msg, ex);
    }
    @Override
    protected void print() {
        System.out.print("son exception happen nested is :");
    }
}

public static void main(String[] args) {
    try {
        System.out.println("开始嵌套异常测试");
        throw new GrandFather("grandfather", new Father("father", new Son("son", null)));
    } catch (GrandFather e) {
        e.print();
    }
    out();
}

private static void out() {
    try {
        System.out.println("\n执行最外层代码");
        mid();
    } catch (GrandFather e) {
        GrandFather grandFather = new GrandFather("2", e);
        grandFather.print();
    }
}

private static void mid() {
    try {
        System.out.println("执行中层代码");
        in();
    } catch (Father e) {
        throw new Father("1", e);
    }
}

private static void in() {
    try {
        System.out.println("执行最里层代码，发生异常");
        throw new Son(null, null);
    } catch (Son e) {
        throw e;
    }
}
// 下面是输出结果
开始嵌套异常测试
grandfather exception happen nested is :father exception happen nested is :son exception happen nested is :
执行最外层代码
执行中层代码
执行最里层代码，发生异常
grandfather exception happen nested is :father exception happen nested is :son exception happen nested is :

二、异常处理

Java的异常处理是通过try…catch…finally语句来实现的，具体格式如下

try {
    可能抛出异常的语句
} catch (异常类型1 异常对象) {
    对异常类型1对象的处理
} catch (异常类型2 异常对象) {
    对异常类型2对象的处理
}
// 如果异常类型有父子继承关系，那么子类型需要放在前面（Exception肯定是最后对吧）
....
finally {
    不管是否出现异常，必须执行的语句
}

如果在方法内，异常抛出的地方没有及时捕获和处理异常，也可以通过将异常抛出，在调用该方法的地方实现异常的捕获和处理，即方法外异常捕获和处理，依照谁调用谁处理的原则。格式如下

public void test() throws Exception1, Exception2 {....}

三、需要注意的地方

网上关于try-catch-finally的博客很多，这里我选取一篇我很喜欢的博客，依照她的思路给出结论（没错，是个妹子），不进行过多的代码验证了。

链接如下：一个妹子的总结

1、finally不会执行

已知有两种情况：

• try语句没有被执行到，如在try语句之前就返回了，这样finally语句就不会执行，这也说明了finally语句被执行的必要而非充分条件是：相应的try语句一定被执行到。
• 在try块中有System.exit(0)这样的语句，System.exit(0)是终止Java虚拟机JVM的，连JVM都停止了，所有都结束了，当然finally语句也不会被执行到。

2、finally和return

结论：finally语句在return语句执行之后，return返回之前执行的。下面是一个生动形象的例子

public class FinallyTest1 {
    public static void main(String[] args) {      
        System.out.println(test11());
    }    
    public static String test11() {
        try {
            System.out.println("try block");
           return test12();
      } finally {
           System.out.println("finally block");
       }
  }
  public static String test12() {
       System.out.println("return statement");
       return "after return";
   }
}
输出结果如下
try block
return statement
finally block
after return

3、try-catch-finally

1）问题一：finally块中的return的优先级怎么样？

结论：finally块中的return语句具有最高优先级，会覆盖try和catch中的return语句。

// 代码略....

)2）问题二：finally是否会修改try中return的值？

// 测试用例1
public class FinallyTest3 {
    public static void main(String[] args) {
        System.out.println(test3());
    }
    public static int test3() {
        int b = 20;
        try {
            System.out.println("try block");
            return b += 80;
        } catch (Exception e) {
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            // 不起作用，这里的b相当于局部变量
            b = 150;
        }
        return 2000;
    }
}
输出结果如下
try block
finally block
b>25, b = 100
100// 说明finally里面的b = 150并没有起作用

再看下面例子：

// 测试用例2
public class FinallyTest6 {
    public static void main(String[] args) {
        System.out.println(getMap().get("KEY").toString());
    }     
    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("KEY", "INIT");         
        try {
            map.put("KEY", "TRY");
            return map;
        }
        catch (Exception e) {
            map.put("KEY", "CATCH");
        }
        finally {
            map.put("KEY", "FINALLY");
            map = null;
        }         
        return map;
    }
}
输出结果如下
FINALLY

为什么测试用例1中finally里的b = 150并没有起到作用，而测试用例2中finally的map.put(“KEY”, “FINALLY”)起了作用，而map = null却没起作用呢？这就是Java到底是传值还是传址的问题了，简单来说就是：Java中只有传值没有传址（具体请查看上一节）。

我的个人理解：可以把try-finally代码块看成一个方法，这个方法在return执行之后，return返回之前调用，方法的参数就是finally代码块里面的变量了，这样就可以解释上面出现的两种情况了（具体原因的可以查看字节码，TODO一下）。

3）问题三：try块里的return语句在异常的情况下会不会被执行？

结论：try块里的return语句在异常的情况不会被执行。

public class FinallyTest4 {
    public static void main(String[] args) {
        System.out.println(test4());
    }
    public static int test4() {
        int b = 20;
        try {
            System.out.println("try block");
            b = b / 0;
            return b += 80;
        } catch (Exception e) {
            b += 15;
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            // 起作用，这里的b是相当于全局变量
            b += 50;
        }
        return b;
    }
}
输出结果如下
try block
catch block
finally block
b>25, b = 35
85

对于上述两个b出现不同的情况，需要注意区分。

4）问题四：catch块里的return语句在异常的情况下会不会被执行

结论：catch块里的return语句在异常的情况会被执行。

public static int test5() {
    int b = 20;
    try {
        System.out.println("try block");
        b = b /0;
        return b += 80;
    } catch (Exception e) {
        System.out.println("catch block");
        return b += 15;
    } finally {
        System.out.println("finally block");
        if (b > 25) {
            System.out.println("b>25, b = " + b);
        }
        b += 50; //无效语句，原理同前
    }
//  return b; 不可达语句
}
输出结果如下
try block
catch block
finally block
b>25, b = 35
35

对于异常处理流程的详细过程，要有个大致的把握，这样万一在工作中碰到，也能做到有的放矢，心中有数。

总访问次数: 389次, 一般般帅 创建于 2018-04-05, 最后更新于 2020-06-25