黑马程序员技术交流社区

标题: 关于证明return是在finally执行后才返回的的问题 [打印本页]
作者: vaanmax    时间: 2013-2-26 14:28
标题: 关于证明return是在finally执行后才返回的的问题
本帖最后由 vaanmax 于 2013-2-26 16:58 编辑

问题： 写一个类证明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之后才执行的，求详解，或者有代码更好一些。小弟在这里谢过了。


作者: 陈圳    时间: 2013-2-26 14:48
本帖最后由 陈圳 于 2013-2-26 14:57 编辑
  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>/*
复制代码
作者: 陈圳    时间: 2013-2-26 14:57
打印结果:/*
        结果:
        return a
        finally run
        a=6
        m=0
        0
        */
感觉确实改变了...
作者: 贾文泽    时间: 2013-2-26 15:18
作者: 陈圳    时间: 2013-2-26 15:21
贾文泽 发表于 2013-2-26 15:18

那你也分析一下我的程序吧,我的证明了finally是在return之前运行的,但是却改变了return m的值...
作者: vaanmax    时间: 2013-2-26 16:01
贾文泽 发表于 2013-2-26 15:18

流程是这样的。但是。。我总觉得，要是用程序的执行结果表达出来的话，是不是有点欠妥当呢。。。
作者: 贾文泽    时间: 2013-2-26 16:12
陈圳 发表于 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语句有详细的说明，请参考
作者: 贾文泽    时间: 2013-2-26 16:14
vaanmax 发表于 2013-2-26 16:01
流程是这样的。但是。。我总觉得，要是用程序的执行结果表达出来的话，是不是有点欠妥当呢。。。 ...

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

那这个题目是不是就有点问题了.那前堤条件就必须为1/2的时候才是finally无法改变,最后一种情况还是改变了呀,..
作者: vaanmax    时间: 2013-2-26 16:51
贾文泽 发表于 2013-2-26 16:14
看下 java2核心技术第一卷 书中第十一章第二节，你就全明白了

谢谢，很详细。:)
作者: 贾文泽    时间: 2013-2-26 16:56
陈圳 发表于 2013-2-26 16:31
那这个题目是不是就有点问题了.那前堤条件就必须为1/2的时候才是finally无法改变,最后一种情况还是改变了 ...

对啊，所以说在finally｛｝代码块中写return语句只是一种不好的习惯，但是还是能写的啊。
作者: hdsjsql    时间: 2013-4-11 13:53
我是这么写的,分两次证明

5.png (38.57 KB, 下载次数: 45)

5.png
作者: hgw147    时间: 2013-4-18 20:34
提示: 作者被禁止或删除 内容自动屏蔽
作者: 李玉江    时间: 2013-5-29 01:20
/*
一个类证明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执行完以后才返回的，但并不是无法改变返回值。如果自己有返回值是会改变的



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2