有return的情况下try_catch_finally的执行顺序

java异常处理之try_catch_finally

看下面的一个列子：

public class TestException {  
    int goabl=1;
    public TestException() {  
    }  

    int testEx() throws Exception {  
        int ret = 1;  
        try {  
            ret++; 
            return ret;
        } catch (Exception e) {  
           ret++;
           return ret;
        } finally {  
           ret=0;         
        }  
    }  

    int testEx1() throws Exception {  
         int ret = 1;  
         try {  
             ret++; 
             int t=ret/(ret-2);//制造一个exception
             return ret;
         } catch (Exception e) {  
            ret++;
            return ret;
         } finally {  
            ret=0;         
         }  
    }  

    int testEx2() throws Exception {  
        int ret = 1;  
        try {  
            ret++; 
            int t=ret/(ret-2);//制造一个exception
            return ret;
        } catch (Exception e) {  
           ret++;
           return ret;
        } finally {  
           ret=0;
           return ret;
        }  
    }  
    int testEx3() throws Exception {  
        int ret = 1;  
        try {  
            ret++; 
            return ret;
        } catch (Exception e) {  
           ret++;
           return ret;
        } finally {  
           ret=0;
           return ret;
        }  
    }  
    int testEx4() throws Exception {  
        try {  
            goabl++; 
            return goabl;
        } catch (Exception e) {  
            goabl++;
           return goabl;
        } finally {  
            goabl=0;

        }  
    }  

    public static void main(String[] args) {  
        TestException testException1 = new TestException();  
        try {  
            System.out.println(testException1.testEx());
            System.out.println(testException1.testEx1());
            System.out.println(testException1.testEx2());
            System.out.println(testException1.testEx3());
            System.out.println(testException1.testEx4());
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  

程序的运行结果是：

2
3
0
0
2

如果你的答案是正确的且知道是为什么，那么下面的内容相信你也不用看了。
首先这里我就不细说java的异常处理机制，想了解的同学可以去看看java异常处理深入研究。
我们首先对try_catch_finally的执行顺序进行说明。
首先我可以很明确的告诉大家try_catch_finally的执行顺序其实很简单，首先是执行try中的 语句如果有异常就直接进入catch，最后finally一定会执行。
这样可能有人会问那为什么第一个的输出不是0呢？别急我们来一个一个说明。

testEx

try语句中没有任何异常所以catch不会执行。ret进行了一次++操作，这时程序进行了返回，在内存中会生成一个临时变量，来保存ret,也就是说ret的值赋给了一个临时变量所以，ret在finally中赋值为零并不会改变返回的值所以输出为2；

testEx1

这次我们人为的在try的语句中制造了exception这样程序会进入到catch中，所以ret被++两次，同样finally中的语句不能对返回值产生影响，所以输出为3；

testEx2

相对于testEx1我们在finally语句中加入了return语句，说以函数的返回值变成了0，这样说名我能函数的返回值实在finally执行结束后才确定的。

testEx3

同testEx2一样由于finally中加入了return语句，返回值为0；

testEx4

在这个函数中我们把操作的对象改为了全局变量，结合最后一个输出我们可以知道函数的返回结果的确是被一个临时变量接收了，所以函数返回的结果是2，但是goabl已经变为0了。

try()里面有一个return语句，那么后面的finally{}里面的code会不会被执行，什么时候执行，是在return前还是return后？

自己写了个代码测试了一下：

public static void main(String[] args) {  
    int i=getInt();  
    System.out.println(i);  
}  
  
private static int getInt() {  
    // TODO Auto-generated method stub  
    try {  
        return 0;  
    } catch (Exception e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }finally{  
        return 1;  
    }  
}

输出的结果是1

案例2：