Java异常总结

1、JAVA异常类图：

运行时异常： 都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。  

非运行时异常 （编译异常）： 是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

                                             

2、自定义异常

如果要自定义异常类，则扩展Exception类即可，因此这样的自定义异常都属于检查异常（checked exception）。如果要自定义非检查异常，则扩展自RuntimeException。

按照国际惯例，自定义的异常应该总是包含如下的构造函数：

• 一个无参构造函数
• 一个带有String参数的构造函数，并传递给父类的构造函数。
• 一个带有String参数和Throwable参数，并都传递给父类构造函数
• 一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

下面是IOException类的完整源代码，可以借鉴。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class IOException extends Exception {     static final long serialVersionUID = 7818375828146090155L;       public IOException()     {         super();     }       public IOException(String message)     {         super(message);     }       public IOException(String message, Throwable cause)     {         super(message, cause);     }       public IOException(Throwable cause)     {         super(cause);     } }

3、finally块和return

首先一个不容易理解的事实：在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static void main(String[] args) {     int re = bar();     System.out.println(re); } private static int bar() {     try{         return 5;     } finally{         System.out.println("finally");     } } /*输出： finally */

很多人面对这个问题时，总是在归纳执行的顺序和规律，不过我觉得还是很难理解。我自己总结了一个方法。用如下GIF图说明。

 

也就是说：try…catch…finally中的return 只要能执行，就都执行了，他们共同向同一个内存地址（假设地址是0×80）写入返回值，后执行的将覆盖先执行的数据，而真正被调用者取的返回值就是最后一次写入的。那么，按照这个思想，下面的这个例子也就不难理解了。

finally中的return 会覆盖 try 或者catch中的返回值。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

public static void main(String[] args)     {         int result;           result  =  foo();         System.out.println(result);     /2           result = bar();         System.out.println(result);    /2     }       @SuppressWarnings("finally")     public static int foo()     {         trz{             int a = 5 / 0;         } catch (Exception e){             return 1;         } finally{             return 2;         }       }       @SuppressWarnings("finally")     public static int bar()     {         try {             return 1;         }finally {             return 2;         }     }

finally中的return会抑制（消灭）前面try或者catch块中的异常

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

class TestException {     public static void main(String[] args)     {         int result;         try{             result = foo();             System.out.println(result);           //输出100         } catch (Exception e){             System.out.println(e.getMessage());    //没有捕获到异常         }           try{             result  = bar();             System.out.println(result);           //输出100         } catch (Exception e){             System.out.println(e.getMessage());    //没有捕获到异常         }     }       //catch中的异常被抑制     @SuppressWarnings("finally")     public static int foo() throws Exception     {         try {             int a = 5/0;             return 1;         }catch(ArithmeticException amExp) {             throw new Exception("我将被忽略，因为下面的finally中使用了return");         }finally {             return 100;         }     }       //try中的异常被抑制     @SuppressWarnings("finally")     public static int bar() throws Exception     {         try {             int a = 5/0;             return 1;         }finally {             return 100;         }     } }

finally中的异常会覆盖（消灭）前面try或者catch中的异常

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

class TestException {     public static void main(String[] args)     {         int result;         try{             result = foo();         } catch (Exception e){             System.out.println(e.getMessage());    //输出：我是finaly中的Exception         }           try{             result  = bar();         } catch (Exception e){             System.out.println(e.getMessage());    //输出：我是finaly中的Exception         }     }       //catch中的异常被抑制     @SuppressWarnings("finally")     public static int foo() throws Exception     {         try {             int a = 5/0;             return 1;         }catch(ArithmeticException amExp) {             throw new Exception("我将被忽略，因为下面的finally中抛出了新的异常");         }finally {             throw new Exception("我是finaly中的Exception");         }     }       //try中的异常被抑制     @SuppressWarnings("finally")     public static int bar() throws Exception     {         try {             int a = 5/0;             return 1;         }finally {             throw new Exception("我是finaly中的Exception");         }       } }

上面的3个例子都异于常人的编码思维，因此我建议：

• 不要在fianlly中使用return。
• 不要在finally中抛出异常。
• 减轻finally的任务，不要在finally中做一些其它的事情，finally块仅仅用来释放资源是最合适的。
• 将尽量将所有的return写在函数的最后面，而不是try … catch … finally中。

4、异常的注意事项

1、当子类重写父类的带有 throws声明的函数时，其throws声明的异常必须在父类异常的可控范围内——用于处理父类的throws方法的异常处理器，必须也适用于子类的这个带throws方法 。这是为了支持多态。

例如，父类方法throws 的是2个异常，子类就不能throws 3个及以上的异常。父类throws IOException，子类就必须throws IOException或者IOException的子类。

至于为什么？我想，也许下面的例子可以说明。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

class Father {     public void start() throws IOException     {         throw new IOException();     } }   class Son extends Father {     public void start() throws Exception     {         throw new SQLException();     } } /**********************假设上面的代码是允许的（实质是错误的）***********************/ class Test {     public static void main(String[] args)     {         Father[] objs = new Father[2];         objs[0] = new Father();         objs[1] = new Son();           for(Father obj:objs)         {         //因为Son类抛出的实质是SQLException，而IOException无法处理它。         //那么这里的try。。catch就不能处理Son中的异常。         //多态就不能实现了。             try {                  obj.start();             }catch(IOException)             {                  //处理IOException             }          }    } }

2、Java程序可以是多线程的。每一个线程都是一个独立的执行流，独立的函数调用栈。如果程序只有一个线程，那么没有被任何代码处理的异常 会导致程序终止。如果是多线程的，那么没有被任何代码处理的异常仅仅会导致异常所在的线程结束。