问题： 写一个类证明return是在finally执行后才返回的，且在finally无法改变返回值。

public class Test5 {
        public static int Demo() {
                int x = 1;
                try {
                        System.out.println("try的 x:" + x);
                        return x;// 需要被检测的代码块
                } finally // 一定会执行的语句
                {
                        x = 3;
                        System.out.println("finally的 x:" + x);//将X的值打印出来
                }

        }
        public static void main(String[] args){
                System.out.println("Demo:..."+Demo());
        }
}

正如大家所见啊，我前些日子，做的基础测试题中有这么一道题，我也从网上找过这个问题的解决方案，差不多就是这样的。但是总觉得的，这个写只是能证明，finally无法改变返回值，但是好像无法证明retrun是在finally之后才执行的，求详解，或者有代码更好一些。小弟在这里谢过了。

1. <div class="blockcode"><blockquote>package Day16;
   
2. class suanFa
   
3. {
   
4.         //一个返回最大值的方法
   
5.         public static int choose(int a,int b)
   
6.         {
   
7.                 int m=0;
   
8.                 try
   
9.                 {
   
10.                         if(a==0||b==0)
    
11.                         throw new byZeroException("选择数不能为0");
    
12.                         if(a>b)
    
13.                         {
    
14.                                 System.out.println("return a");
    
15.                                 m=a;
    
16.                         }
    
17.                                 
    
18.                         else
    
19.                         {
    
20.                                 System.out.println("return b");
    
21.                                 m=b;
    
22.                         }
    
23.                 }
    
24.                 catch(byZeroException e)
    
25.                 {
    
26.                         System.out.println(e.toString());
    
27.                 }
    
28.                 finally
    
29.                 {
    
30.                         System.out.println("finally run");
    
31.                         //通过finally改变返回值
    
32.                         m=0;
    
33.                         System.out.println("a="+a);
    
34.                 }
    
35.                 System.out.println("m="+m);
    
36.                 return m;  //
    
37.         }
    
38. }
    
39. //定义了异常处理函数
    
40. class byZeroException extends RuntimeException
    
41. {
    
42.         byZeroException(String msg)
    
43.         {
    
44.                 super(msg);
    
45.         }
    
46. }
    
47. class Test2
    
48. {
    
49.         public static void main(String[] args)
    
50.         {
    
51.                 //输入反回值方法
    
52.                 System.out.print(suanFa.choose(6,1));
    
53. }
    
54. <blockquote>/*

复制代码

打印结果:/*
        结果:
        return a
        finally run
        a=6
        m=0
        0
        */
感觉确实改变了...

贾文泽 发表于 2013-2-26 15:18

那你也分析一下我的程序吧,我的证明了finally是在return之前运行的,但是却改变了return m的值...

贾文泽 发表于 2013-2-26 15:18

流程是这样的。但是。。我总觉得，要是用程序的执行结果表达出来的话，是不是有点欠妥当呢。。。

陈圳 发表于 2013-2-26 15:21
那你也分析一下我的程序吧,我的证明了finally是在return之前运行的,但是却改变了return m的值... ...

虽然finally代码块是被单独调用的，但是执行顺序还是一定的，在try中没有异常抛出的情况下，先全部执行try中的代码，再执行finally块中的代码，接着执行try｛｝finally｛｝后的第一句代码

1.return语句在try中
  finally代码块中的代码不会影响方法的返回值
2.return语句在finally块中，
  finally代码块中的代码会影响方法的返回值
3.return语句在try中和finally中都有
  finally块中的执行结果会覆盖try块中的return

这样你看你的代码就顺序比较清晰了，
在java2核心技术第十一章第二节对finally代码块跟return语句有详细的说明，请参考

vaanmax 发表于 2013-2-26 16:01
流程是这样的。但是。。我总觉得，要是用程序的执行结果表达出来的话，是不是有点欠妥当呢。。。 ...

看下 java2核心技术第一卷 书中第十一章第二节，你就全明白了

贾文泽 发表于 2013-2-26 16:14
看下 java2核心技术第一卷 书中第十一章第二节，你就全明白了

那这个题目是不是就有点问题了.那前堤条件就必须为1/2的时候才是finally无法改变,最后一种情况还是改变了呀,..

贾文泽 发表于 2013-2-26 16:14
看下 java2核心技术第一卷 书中第十一章第二节，你就全明白了

谢谢，很详细。:)

陈圳 发表于 2013-2-26 16:31
那这个题目是不是就有点问题了.那前堤条件就必须为1/2的时候才是finally无法改变,最后一种情况还是改变了 ...

对啊，所以说在finally｛｝代码块中写return语句只是一种不好的习惯，但是还是能写的啊。

我是这么写的,分两次证明

/*
一个类证明return是在finally执行后才返回的，且在finally无法改变返回值。
@author 李玉江
   
*/
class Test5
{
        public static void main(String[] args)
        {
                System.out.println(getValue1());//调用方法并且输出打印结果是13
                System.out.println(getValue2());//结果是6
        }

        public static int getValue1() //这个方法证明了return是在finally执行后才返回的
                {
                        int a1 = 1;
                        int a2 = 4;//定义两个变量
                        try
                                {
                                        System.out.println(a2+=8);//输出12
                                        return a1+=99;//如果是try的return先执行应该返回的是100       
                                }
                       
                        finally
                                {
                                         //System.out.println(a2+=8);
                                        //return a2++;//返回的是12，
                                        return ++a2;//返回的是13，前++和后++有区别
                                        //return a1;
                                        //return a1+=200;
                                       
                                }
                               
                }

        public static int getValue2()//这个方法证明了finally无法改变返回值，最后还是3。
        {
                /*int a3 = 3;
                try
                {
                        return a3;
                }
                finally
                        {
                                a3+=11;
                        }*/
                       
                        int a3 = 3;
                try
                {
                        return a3+=3;
                }
                finally
                        {
                                a3+=11;//但是此种情况返回的是6而不是14.由此在getValue1的方法中如果是return的a1
                                      //输出的是100,若是return的a1+=200,则输出的是300.
                         System.out.println(a3);//打印出17
                        }
                       
        }
}
/*
总结：在此代码中。try中的return是参与计算了的。但是并没有马上返回给函数。
        如果finally里有return则将其覆盖了。但是finally在其中用到了try的return中的数据仍然会调用try的return。
        若是finally中没有return那么返回的将是try中的return。
        而在getValue2最后中finally打印的是17，只不过返回的却是try的return罢了。
所以：return确实是在finally执行完以后才返回的，但并不是无法改变返回值。如果自己有返回值是会改变的