// 思路：用return的相互覆盖就可以解决这个难题。
public class ReturnRecover{
       
    public static void main(String[] args) {
            //调用下面的方法
            int n = fun(2);
            System.out.println("打印fun（）函数返回的n值=  "+n);
    }
    public static int fun(int i)
    {
            try {
                    //发现异常
                    int m= i/0;
                    //异常直接被捕获，后面的不会执行。
                    return i++;
            }
            catch (ArithmeticException e){
                    System.out.println("异常信息："+e);
                    System.out.println("catch 中的i = "+i);
                    return i+3;   //返回的是 2+3， 而不是finally中对i的赋值再来加上3，
                                        //finally中对i的操作，不会影响此时catch中的return i+3
            }
            finally  {
                    i++;
                    i++;
                    System.out.println("finally 执行  "+i);
                    //return i+8;   //如果这里没注释
                   //这里会返回12，而不会去返回catch中的  return i+3
            }
    }
}
/*        结论：          先执行return后执行finally
* 输出结果为：异常信息：java.lang.ArithmeticException: / by zero
*                                                catch 中的i = 2
*                                                finally 执行  4
*                                                打印fun（）函数返回的n值=  5
* 结果分析：在执行try语句时，由于i/0是会报异常的，所以异常立马被catch捕获，for里面的return是不会执行的
*                                         执行catch语句内容，先输出两个语句，再执行return i+3;   此时i已经是5，所以主函数里面会打印n=5，
*                                         finally中对i的操作，不会影响此时catch中的return i+3
*                                         return执行完成后再执行finally，finally里面执行两次i++，所以输出的i值为4；
* 判断先后的方法：在finally里面加入了return i+8;  此时我们会发现主函数里面输出的是n=12，
*                                 如果是先执行的finally方法，catch里面的return 动作肯定会覆盖finally里面的，所以输出的肯定就不会是n=12
*                                 如果是先执行的try里面的return，输出的结果肯定就会被后来执行的finally方法所覆盖，输出就应该是n=12，满足代码结果
* 所以得出结论是：先执行的try里面的return  ，后执行的finally方法。
*/

这个问题以前还真的没注意过。。

从上到下的吧？finally是一定执行的

/*
*6、 用代码证明，在try中写了return，后面又写了finally，
*是先执行return还是先执行fianlly？
*/
/*
* 执行结果：此时try语句块正在被执行
       此时finally语句块正在被执行
   true
   解释：当java程序在执行try块、catch块时如果遇到了return或者throw时，
   系统去寻找该异常处理流中是否包含了finally语句块，
   如果没有finally块，则程序会立即执行return或者throw语句，方法终止。
   如果有finally语句块，系统会开始立即执行finally语句块，只有当finally语句块中的代码被执行完了之后，系统才会回来再次执行try块或者catch块中的return或throw语句，
   但是如果finally块中也有return或者throw这样能是方法结束的语句，则finally块就会立即结束该方法，系统将不会跳回去执行try块或者catch中的任何语句。
*/
public class Test6
{
        public static void main(String args[])
        {
                System.out.println(test());  
        }
                @SuppressWarnings("finally")
                public static boolean test(){
                        try{
                                //用来检测try块里面处于return前的语句是否有被执行
                                System.out.println("此时try语句块正在被执行");
                                return false;
                        }
                        finally{       
                                //用来检测finally语句块中的语句有没有被执行
                                System.out.println("此时finally语句块正在被执行");
                                return true;
                        }               
                }
               
       
}

好东西，收了

好东西啊

是先执行finally的吧   我用调试 断点看了  先执行finally  然后执行return的

蓝玉 发表于 2015-3-7 15:23
/*
*6、 用代码证明，在try中写了return，后面又写了finally，
*是先执行return还是先执行fianlly？

赞

package com.itheima;

/**
* 第7题：用代码证明，在try中写了return，后面又写了finally，是先执行return还是先执行fianlly？
*
* @author HanSnowqiang
*         有以下代码我们可以看出当程序执行到try中的return语句时，是建立了返回路径的，但并没有马上返回方法要求的int值
*         ，随后执行了finally语句块中的变量修改。 然后在finally语句块结束后回到try中的return语句做了返回的动作。
*         所以我认为是先执行了return语句。可以理解为finally语句块是在return的过程中执行的。
*/
public class Test7 {
        public static void main(String[] args) {
                // 创建方法调用
                System.out.println(getInt() + "---" + "方法调用");
        }

        public static int getInt() {
                // 定义变量并初始化
                int a = 1;
                // 执行try语句
                try {
                        a = 2;
                        System.out.println("try" + "---" + a);
                        return a;// 当程序执行到这里时相当于（return 2）返回路径已经建立了。但发现后面有finally必须执行，所以没有马上返回而是去执行finally语句块。
                }
                // finally必须执行
                finally {
                        // 修改了变量a的值为3
                        a = 3;
                        System.out.println("finally" + "---" + a);
                } // 执行结束后，跳转回（return 2）已经建立的返回路径，返回了2这个int值。
        }
}
// 所以，以上代码的执行结果为       try---2
//                                                finally---3
//                                                2---方法调用

狗屁不通，你们的程序根本没办法知道是先执行retuen还是先执行finally