监控与捕获异常

1　try/catch

l  try的语法

Ø  try 不能单独出现，只能与catch或者finally一起出现。当然，二者都出现也等！

Ø  try与catch之间不能再添加其他代码：try {}catch() {}

l  catch的语

Ø  catch不能单独出现，只能与 try一起使用；

Ø   catch后面有一个圆括号，其中必须且仅能指定一个异常类型，类型后跟随对象名；

2　可以有多个catch

l  多个catch的语法

当一个 try有多个catch时：

出现异常需要从第一个 catch开始查找，如果匹配，那么就由它来处理；如果不匹配，再去查找下一个。以此类推！

查找顺序，从上到下去查找匹配的 catch。

多个catch中最多只有一个catch用来处理异常！

当查找到第一个匹配的catch后，就不会再向下查找了。

当一个try中对应的多个catch处理的异常有继承关系，那么子类在上，父类在下。不然，父类如果在上，那么子类在下，子类就没有捕获异常的机会了！

public class Test {             public  static void main(String[] args) {                       try  {                                if(true)  {                                         throw  new InterruptedException();                                         //throw  new NullPointerException();                                         //throw  new ClassCastException();                                }                       }  catch(NullPointerException e) {                                System.out.println(1);                       }  catch(RuntimeException e) {                                System.out.println(2);                       }  catch(Exception e) {                                System.out.println(3);                       }             }    }

3　catch中异常类型是受检查异常（不包括Exception）时

当 catch中处理的异常类型为受检查异常，那么要求 try中一定要有引发该异常的语句！不然编译不通过！

public class Test {             public  static void main(String[] args) {                       try  {    /*                                boolean  b = false;                                if(b)  {                                         throw  new InterruptedException();                                }    */                       }  catch(InterruptedException e) {//受检查异常                                System.out.println(1);                       }             }    }

4　try中不能抛出catch中没有捕获的异常（不受查检的可以）

public class Test {             public  static void main(String[] args) throws InterruptedException {                       try  {                                //try和catch处理不了这个异常，那么它就会返回，但方法没有声明这个异常就编译不通过                                throw  new InterruptedException();                       }  catch(RuntimeException e) {                                System.out.println(1);                       }             }    }

当try和 catch处理的异常不包含在try中抛出的异常时，那么try和catch就无能为力了，也就是说它们失效了。这时这个异常就会抛出去，即返回给调用者一个异常类的对象。

但是，如果方法没有 throws这个异常，那么就编译不通过。

5　catch中可以抛出异常，但需要在方法上声明

public class Test {             public  static void main(String[] args) {                       try  {                                throw  new InterruptedException();                       }  catch(Exception e) {                                //  可以在catch中抛出异常                                throw  new RuntimeException();                       }             }    }

因为在catch中没有try，所以在catch中抛出异常时，需要在方法上throws这个异常。

当然，你也可以在catch中添加一个try来处理这个throw语句。

总是执行

有时有很多的代码需要必须去执行！这就需要finally块了。

1　只有finally中的代码总是执行

　　在java中只有finally中的东西才能保证总是执行！

2　至上而下，到finally开始执行

　　默认情况下，从上到下执行，到了finally再执行它。

3　在执行finally之前，方法要返回（异常返回和return返回）

在finally执行之前，方法要返回（两种可能：return或者异常）。这时会在返回之前先执行finally块。

这种执行方式我们称之为插入执行finally！

4　如果在finally中返回

　　如果在   finally中存在返回语句，那么其他的返回或者是抛出异常的语句就不可能会生效了。因为它总是在其他返回语句之前要插入执行！

5　当finally插入执行（看看就行）

public class Test {             public  static void main(String[] args) {                       System.out.println(fun());             }                          public  static int fun() {                       int  i = 1;                       try  {                                i++;                                if(false)  {                                         return  i;                                }                                if(false)  {                                         throw  new Exception();                                }                       }  catch(Exception e) {                                i++;                                if(true)  {                                         return  i;                                }                       }  finally {                                //当finllay插入执行时，它就好像是一个调用的方法一样。                                //在finally中使用的所有变量，都是copy过来的。                                //在finally中使用了几个变量，那么就相当于finally这个方法中有几个形参，这都需要实参copy。                                i++;                                System.out.println("finally:  " + i);                       }                       return  i;             }    }

值得学习ing!