用代码证明，在try中写了return，后面又写了finally，是先执行return还是先执行fianlly？
这个题的题意不太明白。用不用考虑finally中写入ruturn的情况呢。提交的时候要不要考虑这个种情况。本来想把我的测试方法贴出来，但是想想还是算了。回答问题的也不要贴代码。

try区块只是表示其后面的一对大括号{}的内容，你说的那种情况我觉得有点没有多大意义，return后面是不能再跟其他语句的，跟了也没法执行。希望能帮到你。

个人觉得还是按题意来写代码

这道题可以用断点来逐步查看运行步骤，如果用代码的话，利用求和的函数，调用方法，返回求和的值，然后通过打印出的顺序可以知道try中的return先执行还是finally先执行。由打印结果可以知道如果try中有return的话finally会先执行然后再返回值，但是finally无法改变返回值。如果return在finally中也有的话将始终返回finally中的return值。

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 //定义三个加数
   
5.                 int x = 2;
   
6.                 int y = 3;
   
7.                 int z = 1;
   
8.                
   
9.                 //调用try中有return的函数
   
10.                 System.out.println("main sum = " +sumMethod1(x,y,z));
    
11.                
    
12.                 System.out.println("------------------------------");
    
13.                
    
14.                 //调用try和finally中都有return的函数
    
15.                 System.out.println("main sum = " +sumMethod2(x,y,z));
    
16.         }
    
17. 
    
18.         private static int sumMethod1(int x, int y,int z) {
    
19.                 //定义一个和数
    
20.                 int sum;
    
21.                 try {
    
22.                         sum = x + y;
    
23.                         //打印出try里的和数
    
24.                         System.out.println("try sum = "+ sum);
    
25.                         //将求和的数返回
    
26.                         return sum;
    
27.                 } finally{
    
28.                         //重定义求和的数
    
29.                         sum = x+z;
    
30.                         //打印出finally里的和数
    
31.                         System.out.println("finally sum = "+ sum);
    
32.                 }
    
33.         }
    
34. 
    
35.         private static int sumMethod2(int x, int y,int z) {
    
36.                 //定义一个和数
    
37.                 int sum;
    
38.                 try {
    
39.                         sum = x + y;
    
40.                         //打印出try里的和数
    
41.                         System.out.println("try sum = "+ sum);
    
42.                         //将求和的数返回
    
43.                         return sum;
    
44.                 } finally{
    
45.                         //重定义求和的数
    
46.                         sum = x+z;
    
47.                         //打印出finally里的和数
    
48.                         System.out.println("finally sum = "+ sum);
    
49.                         //返回求和的sum
    
50.                         return sum;
    
51.                 }
    
52.         }
    
53. }

复制代码

你在try 里面return    这个作用范围只在这个括号里面，  而  finally  会继续执行

复制代码

1 public     class     Test {   public      static      void      main(String[]      args) {        System.out.print(tt());   }   public      static      int      tt() {        int      b      =      23;        try      {         System.out.println("yes");         return      b+=88;        }        catch(Exception      e)      {         System.out.println("error      :      "      +      e);        }        finally      {         if(b>25)       {          System.out.println("b>25      :      "+b);         }         System.out.println("finally");        }      return      b;   } }

复制代码





    代码说明:

     主要是用来测试return和finally语句到底哪个先执行.在try语句中，返回了b=111; 在finally语句中判断是否大于25,如果大的话就输出大..程序的结果是

yes

b>25       :       111

finally

111

    也就是说明finally语句在return语句执行完了以后才执行的.

     OK,那么问题来了,如果我把finally语句改成这样呢:



1 finally      {         if(b>25)       {          System.out.println("b>25      :      "+b);         }         System.out.println("finally");  
2
3      return 100;      }



            也就是在finally中加入return 语句,返回不同的值. 那么,返回值到底是原来的b值(111),还是新的这个返回值呢? 废话不多,看结果:

yes

b>25       :       111

finally

100

     这样又说明了一个问题,finally语句块里面的return把原来的return给覆盖了!!变成了新的返回值了.

     OK,继续闷骚:我把代码改成这样:

try      {         System.out.println("yes");         return      b;        }        catch(Exception      e)      {         System.out.println("error      :      "      +      e);        }        finally      {         if(b>25)       {          System.out.println("b>25      :      "+b);         }         System.out.println("finally");         b=100;      }



           也就是把 try中的返回语句改成返回b值,然后在finally中改变b的值. 那么返回结果到底是原来的b值呢, 还是更改过的b值呢?结果如下:

yes

finally

23

      说明了一个问题，如果finally语句中没有返回语句覆盖的话，那么原来的返回值就不会变,不管你是不是改变了要返回的那个变量.

      最后还是来说说一点点想法,这个机制是不是这样的呢?碰到try语句中的return,那么先把return的值放在某个池中(怎么我也说起池来了，明明根本还不懂的)?      然后执行finally里面的代码块,如果有返回值覆盖语句，就改变先前放在池中的那个值,如果没有,就把那个池中的东西取出来返回出去


如果在try-finally外面在用一个return返回一个值会不会改变在try里面的返回的那个值呢？ 代码如下： public  static  void main(String[] args)     {            System.out.print(tt());       }       public static int tt()     {            int b = 23;            try          {             System.out.println("yes");             return  b =88;            }            catch(Exception      e)          {             System.out.println("error : "             e);            }            finally          {             if(b>25)           {              System.out.println("b>25 : " b);             }             System.out.println("finally");            }          return  100;       }
结果是： yes b>25 : 111 finally 111 答案是不会的。

不管怎样都是先执行try里面的语句，如果try中有return就先执行然后在执行finally中的语句，而不会执行catch中的语句。

先执行return 通过可以myeclipse进行断点测试