Effective Java 学习笔记之异常

1) Throwable 所有的异常类的一个共同的祖先

2) Error 程序无法处理的错误 表示运行应用程序中比较重要的问题，与代码执行操作无关，表示运行时JVM出现的问题,这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。

3) Exception 程序可以进行处理的错误

Exception可以分为 运行时异常 和 非运行时异常 两大类

• 运行时异常 指的是RuntimeException和其子类 表示JVM常用操作引发的错误。比如有ArithmaticException,ClassNotFoundException,IllegalArgumentException。

  • 这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
  • 一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
  • Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

• 非运行时异常 也称作编译异常 是RuntimeException以外的异常类，类型上都属于Exception类及其子类。

  • 从程序语法角度讲是必须进行处理的异常，如果不处理编译的时候就无法通过
  • 如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

4）Java中的异常也可以分为 可查异常checked exception 和 不可查异常 unchecked exception两大类

• 可查异常checked exception 是编译器要求必须处置的异常

  • 可查的异常虽然是异常情况，但是在一定程度上它的发生是可以预计的， 而且一旦发生就必须采取某种措施进行处理
  • 除了RuntimeException和其子类，其他的Exception都属于可查异常。
  • 这种异常的特点是编译器会检查它。当程序中可能出现这类异常，要么用try-catch捕获，要么用throws声明抛出，否则编译不会通过。

• 不可查异常 unchecked exception 是编译器不要求强制处置的异常

  • 包括运行时异常(RuntimeException与其子类)和错误(Error)

5）Java中的异常处理机制主要有 抛出异常 和 捕获异常

• 抛出异常：
  
  • 当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，
  • 异常对象中包含了异常类型和异常出现时的程序状态等异常信息。
  • 运行时系统负责寻找处置异常的代码并执行。
• 捕获异常:
  
  • 在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器(exception handler)
  • 潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。
  • 当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器
  • 运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。
  • 当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止.同时，意味着Java程序的终止

总结

• try块:用于捕获异常
• catch块:处理try捕获到的异常
• finally:无论是否不会或处理异常都会执行

finally语句块将在方法返回之前被执行，但是以下四种情况不执行：

1. finally语句内发生异常
2. 前面代码System.exit();
3. 程序所在的线程死亡
4. 关闭cpu

try、catch、finally语句块的执行顺序:

1)当try没有捕获到异常时：

• try语句块中的语句逐一被执行
• 程序将跳过catch语句块
• 执行finally语句块和其后的语句

2)当try捕获到异常

• 2.1)catch语句块里没有处理此异常的情况

  • 此异常将会抛给JVM处理
  • finally语句块里的语句还是会被执行

  • 但finally语句块后的语句不会被执行

  • 2.2)catch语句块里有处理此异常的情况

    • 在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块,并与catch语句块逐一匹配，找到与之对应的处理程序，
    • 其他的catch语句块将不会被执行，
    • 而try语句块中，出现异常之后的语句也不会被执行
    • catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

抛出异常throw/throws

Throws抛出异常的规则：

1) 如果是不可查异常（unchecked exception）即Error、RuntimeException或它们的子类，可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
2) 必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
3) 仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
4) 调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类

例子

public class TestException {
    public TestException() {
    }

    boolean testEx() throws Exception {
        boolean ret = true;
        try {
            ret = testEx1();
        } catch (Exception e) {
            System.out.println("testEx, catch exception");
            ret = false;
            throw e;
        } finally {
            System.out.println("testEx, finally; return value=" + ret);
            return ret;
        }
    }

    boolean testEx1() throws Exception {
        boolean ret = true;
        try {
            ret = testEx2();
            if (!ret) {
                return false;
            }
            System.out.println("testEx1, at the end of try");
            return ret;
        } catch (Exception e) {
            System.out.println("testEx1, catch exception");
            ret = false;
            throw e;
        } finally {
            System.out.println("testEx1, finally; return value=" + ret);
            return ret;
        }
    }

    boolean testEx2() throws Exception {
        boolean ret = true;
        try {
            int b = 12;
            int c;
            for (int i = 2; i >= -2; i--) {
                c = b / i;
                System.out.println("i=" + i);
            }
            return true;
        } catch (Exception e) {
            System.out.println("testEx2, catch exception");
            ret = false;
            throw e;
        } finally {
            System.out.println("testEx2, finally; return value=" + ret);
            return ret;
        }
    }

    public static void main(String[] args) {
        TestException testException1 = new TestException();
        try {
            testException1.testEx();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果

i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false

ps: finally中使用return是一种很不好的编程风格，它会覆盖掉所有的其它返回，并且吃掉catch中抛出的异常，使catch里throw的Exception不起作用

---