关于try语句的执行顺序

Question

假如try{}里有一条return语句，finally里的语句会在return前执行还是会在return后执行？请勿只回复一个“前”或者“后”，请给出理由。在线等，答案确定立刻结帖。

Answer 1

理由就是 谁制定了这个规则去问谁现在应该去问oracle了

Answer 2

finally不管在什么情况之下都会执行，执行的时间是在程序return 之前.

Answer 3

为方便上一个C#的：static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("executed in try");
                return;
            }
            finally
            {
                Console.WriteLine("executed in finally");
            }
            Console.WriteLine("test over!");
        }result：
executed in try
executed in finally

Answer 4

实在是没什么理由。就像1楼说的，人家制定好的规则，我们在用而已try里的return会先执行；
然后执行finally里的return。他会覆盖掉之前的值。最后返回的就是finally里的。

Answer 5

那么三楼的结果就是在return后执行了？

Answer 6

话说其实这也看不出来怎么谁先执行的，又测试了一下，如果没有try的话那么程序遇到return，会直接跳到main结束的花括号处，但是在try中遇到return的话不会直接跳到最后的花括号，而是先执行finally，所以推断出，finally应该早于return执行。

Answer 7

finally语句里的return不会执行 try块里的语句会等到finally语句执行完后才执行

Answer 8

可以肯的告诉你是在return 前执行！！

Answer 9

应该是return 之前会finally一下吧

Answer 10

假如try{}里有一条return语句，finally里的语句会在return前执行还是会在return后执行？
在return 前啊 ，finally里面的语句肯定要执行的 

Answer 11

  会在return 之前执行finally ，如果，不在之前，那return 过去了，那finally里面的就没有执行了

Answer 12

来两个例子。
public static int test()
{
int a=0;
try
{
return a;
}
finally
{
++a;
}
}
public static int test2()
{
int a=0;
try
{
return a;
}
finally
{
return ++a;
}
}
public static void main(String args[])
{
System.out.println(test());
System.out.println(test2());
}
输出
0
1

Answer 13

这个是正确的，在return以前就执行了

Answer 14

我不太了解为什么结果是0,1  但是这样写的话finally里的return语句会有警告

Answer 15

好像是finally先执行，然后执行catch里的return，但是如果return的值被finally修改过的话还是取修改之前的。
如果finally里面也有return值则执行finally的return，会忽略catch那个return。

Answer 16

finally在覆盖try的return在try后执行

Answer 17

  public static int a=0;
   public static int test0()
    {
       // int a=0;
        try
        {
            return a;
        }
        finally
        {
            ++a;
        }
    }
   /*
    public static int test2()
    {
        int a=0;
        try
        {
            return a;
        }
        finally
        {
            return ++a;
        }
    }
    */
    public static void main(String args[])
    {
        System.out.println(a);
       // System.out.println(test2());
    }
输出为0，说明return 后finally 没有执行，test2执行能返回1，是将try中的return 覆盖掉了 

Answer 18

这个确实错了。。
我想说的是有返回值的情况下，jvm会先看try里有没有return；
有的话，先存储return的值。接下来才到finally；
再然后 取出之存储的值，执行return操作。

Answer 19

如果是无返回类型的，就简单了，直接插到 return之前执行，看下字节码，就清楚了。
 public class test
 {
public static void  test()
    {
        int a=0;//init a
try{
a++;
return ;
}
finally
{
a--;
}
    }
 }

public static void test();
  Code:
   0:   iconst_0   //初始化 0  当前操作数
   1:   istore_0   //操作数存入 0 的位置
   2:   iinc    0, 1  //0位置的数 加 1 ；这里是try中的 a++
   5:   iinc    0, -1 //0位置的数 减 1 ；finally中的操作
   8:   return    //返回
   //下面的是异常时候 执行finally操作 然后抛出异常
   9:   astore_1
   10:  iinc    0, -1
   13:  aload_1
   14:  athrow

Answer 20

public class Catch {
public static int test() {
int a = 0;
try {
System.out.println("try:"+a);
return a;
} finally {
System.out.println("finally:"+a);
}
} public static void main(String args[]) {
System.out.println(test());
}}
try:0
finally:0
0

Answer 21

简单的说 就是一个try 里面 无论什么情况 finally都会执行一次！

Answer 22

修改15楼例子说下
    public static int test2()
    {
        int a=0;
        try
        {
            return a++;
        }
        finally
        {
            return ++a;
        }
    }
执行了try的a之后，会跳到finally执行++a,然后跳到try的a++然后到finally返回
看字节码可以证明前面的几句话，最后说到finally返回可以参考下面的代码
public static int test()
{
int a = 0;
int b = 0;
       try{
       return b;
      }finally
      {
       return ++a;
      }
}

Answer 23

finally块中的内容在控制转出try块前执行。return语句是转出try块的一个方式，所以在return前会执行finally块

Answer 24

try{
return 1
}catch(Exception e){
return 2
}finally{
return 3
}
最终返回的是3如果finally里面没有return，无异常返回1，有异常返回1