这是黑马的一道老题，用代码证明，在try中写了return，后面又写了finally，是先执行return还是先执行fianlly？我写的代码是

1. public class IfDemo {
   
2.                 public static void main(String[] args){
   
3.                        
   
4.                         System.out.println(test(5,0));
   
5.                 }
   
6.                 //自定义一个test测试函数
   
7.                 public static int test(int x,int y){
   
8.                         try{
   
9.                                 //用来检测try块里面处于return前的语句是否有被执行
   
10.                                 int a = x/y;
    
11.                                 System.out.println("try语句块被执行");
    
12.                                 return 1;
    
13.                         }catch (Exception e) {
    
14.                                 System.out.println("算数异常");
    
15.                                 return 2;
    
16.                         }finally{       
    
17.                                 //用来检测finally语句块中的语句有没有被执行
    
18.                                 System.out.println("finally语句块被执行");
    
19.                                 return 3;
    
20.                         }               
    
21.                 }
    
22. }

复制代码

但是感觉这样也无法证明先执行的try语句里面的return还是先执行的finally语句

应该是在执行try里面的return之前跳到finally执行，由于finally里又有1个return，这里执行完finally的return就结束了。所以返回的应该是return 3

黄蒙 发表于 2015-8-16 18:47
应该是在执行try里面的return之前跳到finally执行，由于finally里又有1个return，这里执行完finally的retur ...

但是怎么证明呢

硫氢化铁 发表于 2015-8-16 18:57
但是怎么证明呢

你这打印出来的不是3吗？

楼主可以参考下我的

1. /**
   
2. *
   
3. *如果是只有try中有return而finally中没有的话，是先执行finally再执行return。
   
4. *
   
5. * 如果有finally语句块，系统会开始立即执行finally语句块，只有当finally语句块中的代码被执行完了之后，
   
6.       系统才会回来再次执行try块中的return语句，
   
7. * 但是如果finally块中也有return这样能结束方法的语句，则finally块就会立即结束该方法，
   
8.       系统将不会跳回去执行try中的任何语句。
   
9. *
   
10. *比如示例，x=1自增为x=2，如果try中的return被返回，结果应该为2，而当前结果是1，
    
11.     这是因为finally的return语句立即结束了该方法，try中的return没有被执行。
    
12.    而如果将finally中的return方法注释后，返回结果就为所需要的值2，所以finally是先于return执行的。
    
13. *
    
14. */
    
15. public class Test7 {
    
16. 
    
17.         /**
    
18.          * @param args
    
19.          */
    
20.         public static void main(String[] args) {
    
21.                
    
22.                 System.out.println("最终的返回值为:"+show());
    
23.         }
    
24.        
    
25.         public static int show(){
    
26.                
    
27.                 int x = 1;
    
28.                 try
    
29.                 {
    
30.                         System.out.println("try代码块正在被执行");
    
31.                         x++;
    
32.                         System.out.println("try中最后的x值为:"+x);
    
33.                         return x;
    
34.                 }
    
35.                 finally
    
36.                 {
    
37.                          System.out.println("finally代码块正在被执行");
    
38.                          System.out.println("finally代码块接收到的值为:"+x);
    
39.                          return x=x-1;
    
40.                 }
    
41.        
    
42.         }
    
43. 
    
44. }
    

复制代码

你这执行就是算数异常    然后执行finally语句块被执行然后输出3

运行结果是：
算数异常
finally语句块被执行
3

楼楼你把你的最后的那个return 3 去掉再执行就会变成下面这样
算数异常
finally语句块被执行
2

说明应该是：finally语句肯定是在return语句前面执行，没有执行finally中的语句就一定不会执行return语句
例外就是如果在finally之前会执行到这个语句的话 System.exit();  finally中的内容就不会执行了。

刚刚把你代码改了下：：
比较蛋疼！有好多种情况！
分两大类：
1 参数正常没有0
   1-1 try(return) catch(return) 就会执行try中的return
   1-2 try(return) catch(return)finally(return)执行finally中的return
   1-3 try(return) finally(return)执行finally中的return
2 参数错误 -楼楼可以看看结果
   2-1 try(return) catch(return)
   2-2 try(return) catch(return) finally(return)
   2-3 try(return) finally(return)
   2-4 try(return) finally()
   2-5 try(return) catch( ) finally(return)
   2-6 try(return) catch(return) finally()
   2-7 try(return) catch() finally()

pengbeilin 发表于 2015-8-16 21:13
运行结果是：
算数异常
finally语句块被执行

我给试试

yongyinqi 发表于 2015-8-16 19:30
楼主可以参考下我的

这样啊，多谢

楼主可以运行下这个代码，这是传智风清扬老师的演示代码

1. class FinallyDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 System.out.println(Demo());
   
6.         }
   
7.         public static int Demo()
   
8.         {
   
9.                 int a = 10;
   
10.                 try
    
11.                 {       
    
12.                         a = 20;
    
13.                         return a;
    
14.                 }
    
15.                 catch (ArithmeticException e)
    
16.                 {
    
17.                         a = 30;
    
18.                         return a;
    
19.                 }
    
20.                 finally
    
21.                 {
    
22.                         a = 40;
    
23.                 }
    
24.                
    
25.         }
    
26. }

复制代码

根据这个代码可以看出return语句分两段执行，先形成了返回路径，但暂停了没有立即返回，此时a=20；然后执行finally，a赋值为40；然后再继续运行return语句，返回20。按照风老师的说法是finally语句是运行在return中间的。
楼主可以参考下这个说法

finally里面的内容永远都会执行，除了一种特殊情况：在执行到finally之前退出了虚拟机

还没学到那呢 爱莫能助