有关try..catch..finally处理异常的总结

//看一下下面的程序，你能正确的写出不同的testEx2()方法时，程序的最终打印出来的数据吗....先不要看下面的答案
public class ExceptionTest {  
    public ExceptionTest() {  
    }  
  
    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(){  
        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 ret;  
        } catch (Exception e) {  
            System.out.println("testEx2, catch exception");  
            ret = false;  
            throw e;
        } finally {  
            System.out.println("testEx2, finally; return value=" + ret);  
            return ret;  
        } 
    } */
   
    
    //第二种:
     boolean testEx2() throws Exception {  
        boolean ret = true;   
            int b = 12;  
            int c;  
            for (int i = 2; i >= -2; i--) {  
                c = b / i;  
                System.out.println("i=" + i);  
            }  
            System.out.printf("这句话打打出来了吗??????");
            return true;  
      }
    

    //第三种：
    /*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 ret;  
        } catch (Exception e) {  
            System.out.println("testEx2, catch exception");  
            ret = false;  
            throw e;
        } finally {  
            System.out.println("testEx2, finally; return value=" + ret);  
            //return ret;  //此处不写return 语句
        } 
        //System.out.println("fhsdfsdofi");//因为try中有一个直接return语句，所以这两句不能被访问
        //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);  
            }   
        } catch (Exception e) {  
            System.out.println("testEx2, catch exception");  
            //ret = false;  
            throw e;
        } finally {  
            System.out.println("testEx2, finally; return value=" + ret);  
            //return ret;  //此处不写return 语句
        } 
        System.out.println("这句话打印出来了！！！！");
        return ret;
    } */
    //第五种：
    
    /*boolean testEx2() throws Exception{  //提醒一下，第四种和第五种只有catch中有没有 throw e 不一样
        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 ret;  
        } catch (Exception e) {  
            System.out.println("testEx2, catch exception");  
            ret = false;  
            //throw e;
        } finally {  
            System.out.println("testEx2, finally; return value=" + ret);  
            //return ret;  //此处不写return 语句
        } 
        System.out.println("这句话打印出来了！！！！！！！");
        return ret;
    }*/
    
    public static void main(String[] args) {  
        ExceptionTest testException1 = new ExceptionTest();  
        try {  
            testException1.testEx();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  

class myException extends Exception{
   public void printException(){
      System.out.println("产生异常！");
   }
}

/*异常看着容易，理解起来也很容易！但是它真的没有你想像的那么简单！
第一种：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false

第二种：
i=2
i=1
testEx1, catch exception
testEx1, finally; return value=false
testEx, finally; return value=false

第三种：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, finally; return value=false

第四种：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=true
testEx1, catch exception
testEx1, finally; return value=false
testEx, finally; return value=false

第五种：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
这句话打印出来了！！！！！！！
testEx1, finally; return value=false
testEx, finally; return value=false


总结一下：
一：throw new Exception（）
    第一种情形：(由第二种情形验证)
    int test() throws Exception{
       if(....)
          throw new Exception();
       ....
       return x;
    }
    第二中情形：第五种情况可验证
    int test() throws Exception{
       try{
         if(...)
           throw new Exception();
       }catch(ArithmeticException e){//在try中产生的异常没有被捕获时：
          ....
       }finally{
          ....
       }
       .....
       return x;
    }
   在执行到throw 时，第一种先将return返回个调用者（也就是throw和return之间的语句不会被执行），然后再调用程序中寻找处理异常的程序
   第二种还要将 finally中的语句执行完（即异常有没有被立即处理都要执行finally），（throw和return之间的语句也不会被执行），
   然后执行return语句，程序转向调用者中寻找异常处理程序。
二：再让我们看一下finally中写return的一些缺憾
1 finally块中的return语句会覆盖try块、catch块中的return语句
2 如果finally块中包含了return语句，即使前面的catch块重新抛出了异常，则调用该方法的语句也不会获得catch块重新抛出的异常，
而是会得到finally块的返回值，并且不会捕获异常，也就是如果在catch或者try中产生的异常如果在向外界抛出是不可能的。。。。

第一种情况：testEx2（）方法中会产生一个ArithmeticException的异常， Exception是它的父类，我们在该方法中捕获了该异常并进行了处理
所以会输出 testEx2()中的 catch 和 finally 中的输出数据， 而在testEx1（）方法中，调用了testEx2（），由于testEx2（）中的异常已经被处理
并且由于finally中的return语句导致testEx2（）中catch中的throw e 无法重新抛出，所以在testEx1（）中不会被捕获。

再说一下第四，第五种情况：fianlly中都没有return
在第四种情况中， 由于在catch中继续抛出了该异常，该异常在testEx2（）中没有被处理，所以在执行finally之后的语句（除了return语句）不会被执行，
而第五种是没有继续抛出该异常，也就是textEx2（）中产生的异常全部被处理了，所以finally之后的语句会被执行.....其他不多说。

如果还是没有搞懂的话，推荐看一下下面这个链接，写的不错....
http://blog.csdn.net/hguisu/article/details/6155636
*/