try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code什么时候被执行？
网上搜索的答案，有回答是之前的，可是我自己写了代码理解为是之后，因为我理解的return语句执行完后，不是马上返回到其他程序执行，而是跳出try{},然后把finally{}执行完了再跳转；不知道我的理解对不对？还请高手指点，以下是我的实验代码：

1. package javabase.finallytest;
   
2. 
   
3. /*
   
4. * 解释：
   
5. 在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。
   
6. 在转去之前，try中先把要返回的结果存放到不同于x的局部变量中去，执行完finally之后，在从中取出返回结果，
   
7. 因此，即使finally中对变量x进行了改变，但是不会影响返回结果。它应该使用栈保存返回值(可以理解为finally语句是在return语句后执行的，return语句实现并不是马上返回主函数，而是等执行完finally语句后返回)
   
8. 如果finally里面还有return 值，则try里面的return值，最终会被finally里的return值所覆盖
   
9. */
   
10. 
    
11. public class FinallyTest {
    
12.         public static void main(String[] args) {
    
13.                 System.out.println(FinallyTest.test());
    
14.         }
    
15. 
    
16.         static int test() {
    
17.                 int x = 8;
    
18.                 try {
    
19.                         System.out.println("before return" + x);
    
20.                         return x;
    
21.                 } finally {
    
22.                         System.out.println("before finally" + x);
    
23.                         ++x;
    
24.                         System.out.println("after finally" + x);
    
25.                 }
    
26.         }
    
27. }
    

复制代码

看了楼主的解释感觉是对的。。
源程序输出结果：
before return8
before finally8
after finally9
8
----------------------
如果代码改成：
public class FinallyTest {
        public static void main(String[] args) {
                System.out.println(FinallyTest.test());
        }

        static int test() {
                int x = 8;
                try {
                        System.out.println("before return" + x);
                        return x;
                } finally {
                        System.out.println("before finally" + x);
                        ++x;
                        if(x>8)
                                return x;
                        System.out.println("after finally" + x);   
                }
        }
}
输出结果：
before return8
before finally8
9

楼主您好，我自己写了个代码验证了一下：

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 System.out.println(returnA());//打印结果是0
   
5. 
   
6.         }
   
7. public static int returnA()
   
8. {
   
9.         int x = 0;
   
10.         try
    
11.         {       
    
12.                 return x;
    
13.         }
    
14.         finally
    
15.         {
    
16.                 ++x;
    
17.         }
    
18. }
    
19. }

复制代码

根据打印结果为0，所以我支持是它先执行完return语句，然后在执行finally中代码的说法。
希望可以帮到楼主，有什么不对的，欢迎批评指正。

finally肯定会被执行 在return之后

系统执行完return语句之后，并不会立即结束该方法，而是去寻找该异常处理流程中是否包含finally块，如果没有finally块，则方法终止，返回相应的返回值；如果有finally块，系统会立即执行finally块，只有当finally执行完之后，系统才会再次跳回来根据return语句结束方法。如果finally块里使用了return语句来导致方法结束，则finally块已经结束了方法，系统将不会跳回去执行try、catch里的任何代码。

依照我的理解的话， try catch 是扑捉异常错误的函数，死定理，finally中的语句不论是否出错都会被执行，一般在io关流的时候用得比较多，你这样做，我觉得没有讨论的意义。