在try的括号里面有return一个值,那是否还执行finally里的代码。是在return前执行还是return后执行??

解决方案 »

  1.   

    肯定执行啊
    应该是return之后执行
    try完毕执行finally啊
      

  2.   

    我如果说:在return之后,函数返回之前。你是不是当场疯了?
      

  3.   

    finally 肯定会执行。不管在return 的前面还是后面。
      

  4.   

    return 只是个赋值操作,而已,finally肯定要执行的啊,除非exit了
      

  5.   

    我代码验证过了,你断点跟一下就知道了。先执行try里面的return,但是返回值还没出去又被finally抓回来执行了,最后只返回一个输出值,结果是falsepublic class T {
        public static boolean test() {
            try {
                return true; //先执行return
            } catch (Exception e) {
            } finally {
                return false; //再执行finally里的内容,最后返回的是finally里的值
            }
        }    public static void main(String[] args) {
            System.out.println(test());
        }
    }
      

  6.   

    这是曾经ZangXT回答过的问题,我只是借花献佛给你整出来~~
      

  7.   

    要是这样的话就疯了。。
    其实有两种情况。。
    1、try不出异常 则return之前执行,先finally在return
    2、try出异常  则先finally,不执行try里的return了。。
      

  8.   

    不管 try里面是什么  都会执行后面的finally语句,好好学习吧
      

  9.   

    finally是必定会执行的,遇到return就会跳到finally里
      

  10.   

    finally肯定是要执行的,即使你在try中用了return 那么也要wait()等到finally执行完成再返回。
    不过,一般情况下在try中一般不用return,而是在最后才用return返回。
      

  11.   

    没错finally是必走的,是在return后执行的我用过
      

  12.   

    正解!我再扩展一下。如果finally语句中再加一个return语句,那执行try中还是finally中的return呢?【答案是:执行finally中的return,try中return不再执行。 
      

  13.   

    首先,在执行java语言级的return的时候不仅仅是一步操作!有好几条指令的finally就在这好几条指令之间执行的
    java -p一下class文件一目了然
      

  14.   


    try 中的return 会执行的..只不过 先执行了try 的 return  最终返回的时候又执行了 finally的 return 。public class T {
    static int i=0;
        public static int  test() {
            try {
                return ++i;    //先执行return
            } catch (Exception e) {
            } finally {
                return ++i;    //再执行finally里的内容,最后返回的是finally里的值
            }
        }    public static void main(String[] args) {
            System.out.println(test());
        }
    }
    输出2
      

  15.   


    try 中的return 会执行的..只不过 先执行了try 的 return  最终返回的时候又执行了 finally的 return 。public class T {
    static int i=0;
        public static int  test() {
            try {
                return ++i;    //先执行return
            } catch (Exception e) {
            } finally {
                return ++i;    //再执行finally里的内容,最后返回的是finally里的值
            }
        }    public static void main(String[] args) {
            System.out.println(test());
        }
    }
    输出2
      

  16.   


    try 中的return 会执行的..只不过 先执行了try 的 return  最终返回的时候又执行了 finally的 return 。public class T {
    static int i=0;
        public static int  test() {
            try {
                return ++i;    //先执行return
            } catch (Exception e) {
            } finally {
                return ++i;    //再执行finally里的内容,最后返回的是finally里的值
            }
        }    public static void main(String[] args) {
            System.out.println(test());
        }
    }
    输出2
      

  17.   

      大概试了一下,debug的时候,在try或者catch中走到return的时候(不知道执行了没有),就跳到了finally中,执行了finally中的return。最终的返回结果也是finally中return的值。
      可以简单地理解为,finally覆盖了前面的如return。
      

  18.   

    哈哈,还可以try第一步结果断电了,fi什么啊 re什么啊都没了
      

  19.   

    public class T {
    static boolean r = false;
        public static boolean test() {
    //     boolean r = false;
            try {
             r = true;
                return r;    //注意,最后返回值是try里面的
                
            } catch (Exception e) {
            } finally {
             r = false;
            }
            return r; // 此处不会执行
        }    public static void main(String[] args) {
            System.out.println(test());
        }
    }
      

  20.   

    肯定是先执行 finally  然后 在 执行 return 
      

  21.   

    分两种情况
    如果没有异常,遇到return就直接跳到finally,执行完毕以后再return.
    如果发生异常,那么就不管return,直接finally不知道这样能不能理解,总的来说,你可以理解成,无论如何,都是先finally,然后再说return
      

  22.   

    public class Test { public String inputss(){
    try {
    return "你哥";
    } catch (Exception e) {
    }
    finally{
    System.out.println("你妹");
    }
    return null;
    }
    public static void main(String[] args) {
    Test test=new Test();
    String s=test.inputss();
      System.out.println(s);

    }}
    结果是:你妹
            你哥
      

  23.   

    try中的finally是一定执行的 
      

  24.   

    finally先执行、、任何时候执行return之后该方法其他都不会执行了、
      

  25.   

    你的答案是在return之前,但往更细地说,我的答案是在return中间执行,请看下面程序代码的运行结果: public  class Test {      /**      * @param args add by zxx ,Dec 9, 2008      */     public static void main(String[] args) {          // TODO Auto-generated method stub          System.out.println(new Test().test());;     }     static int test()     {          int x = 1;          try          {              return x;          }          finally          {              ++x;          }     }}---------执行结果 ---------1运行结果是1,为什么呢?主函数调用子函数并得到结果的过程,好比主函数准备一个空罐子,当子函数要返回结果时,先把结果放在罐子里,然后再将程序逻辑返回到主函数。所谓返回,就是子函数说,我不运行了,你主函数继续运行吧,这没什么结果可言,结果是在说这话之前放进罐子里的。这个应该有总结了