Effective Java 学习笔记之异常

拼搏现实的明天。 2022-06-14 07:17 265阅读 0赞

![这里写图片描述][SouthEast]

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不起作用

--------------------

[SouthEast]: /images/20220614/9c6df52f4be24499a8ca9babc3f03029.png