有关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
*/