首页 > 试题广场 >

下面代码运行结果是（）

[单选题]

下面代码运行结果是（）

public class Test{	
    public int add(int a,int b){	
         try {	
             return a+b;		
         } 
        catch (Exception e) {	
            System.out.println("catch语句块");	
         }	
         finally{	
             System.out.println("finally语句块");	
         }	
         return 0;	
    } 
     public static void main(String argv[]){ 
         Test test =new Test(); 
         System.out.println("和是："+test.add(9, 34)); 
     }
}

```
catch语句块
和是：43
```
```
编译异常
```
```
finally语句块
和是：43
```
```
和是：43
finally语句块
```

查看答案及解析

贱贱的梦想

先来看一段代码：

public abstract class Test {
    public static void main(String[] args) {
        System.out.println(beforeFinally());
    }
    
    public static int beforeFinally(){
        int a = 0;
        try{
            a = 1;
            return a;
        }finally{
            a = 2;
        }
    }
}
/**output:
1
*/

从结果上看，貌似`finally` 里的语句是在`return` 之后执行的，其实不然，实际上`finally` 里的语句是在在`return` 之前执行的。那么问题来了，既然是在之前执行，那为什么`a` 的值没有被覆盖了？
实际过程是这样的：当程序执行到try{}语句中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally{}中的程序， 在执行`a = 2`时，程序仅仅是覆盖了a的值，但不会去更新临时栈中的那个要返回的值 。执行完之后，就会通知主程序“finally的程序执行完毕，可以请求返回了”，这时，就会将临时栈中的值取出来返回。这下应该清楚了，要返回的值是保存至临时栈中的。
再来看一个例子,稍微改下上面的程序：

public abstract class Test {
    public static void main(String[] args) {
        System.out.println(beforeFinally());
    }
    
    public static int beforeFinally(){
        int a = 0;
        try{
            a = 1;
            return a;
        }finally{
            a = 2;
            return a;
        }
    }
}
/**output:
2
*/

在这里，finally{}里也有一个return，那么在执行这个return时，就会更新临时栈中的值。同样，在执行完finally之后，就会通知主程序请求返回了，即将临时栈中的值取出来返回。故返回值是2.

编辑于 2016-07-16 16:24:16 回复(77)

蜕变与成长

1.finally{}代码块比return先执行。

2.多个return是按顺序执行的的，多个return执行了一个后，后面的return就不会执行了。

3. 记住一点，不管有不有异常抛出， finally都会在return返回前执行。

以上结论是自己在eclipse中编译测试过的，不正确之处请多多指教

编辑于 2015-09-25 13:26:28 回复(20)

想要offer的菜戟

try–catch–finally块的执行顺序:先执行finally 若try中出现了异常则会调用catch中寻找异常解决方法

发表于 2022-03-12 19:57:34 回复(0)

离人煮酒

为什么不是先输出：和是 finally块 43的原因。

System.out.println("和是："+test.add(9, 34)); 这是进行字符串拼接是一个整体，所以首先是进入add方法中，进去之后先把先不运算result，而是输出finally块。注意：此时finally块输出结果是：finally语句块，这句话首先打印到控制台中。打印完后返回来执行try中的return得到43，所以此时再将结果与"和是："进行拼接-->输出：和是 43。所以此时控制台又多了一句话：和是 43。加上之前finally先在控制台上的输出，所以结果为：finally语句块和是 43.

如果还没看懂的话可以4行和15行这里打断点进行调试，你将一目了然。看博客http://www.cnblogs.com/lirenzhujiu/p/5754267.html

编辑于 2016-08-09 18:30:47 回复(11)

牛客3212507号

结论：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
举例：
情况1 ：try{} catch(){}finally{} return;
            显然程序按顺序执行。
情况2 :try{ return; }catch(){} finally{} return;
          程序执行try块中return之前（包括return语句中的表达式运算）代码；
         再执行finally块，最后执行try中return;
         finally块之后的语句return，因为程序在try中已经return所以不再执行。
情况3 :try{ } catch(){return;} finally{} return;
         程序先执行try，如果遇到异常执行catch块，
         有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，
                     最后执行catch块中return. finally之后也就是4处的代码不再执行。
       无异常：执行完try再finally再return.
情况4 :try{ return; }catch(){} finally{return;}
          程序执行try块中return之前（包括return语句中的表达式运算）代码；
          再执行finally块，因为finally块中有return所以提前退出。
情况5 :try{} catch(){return;}finally{return;}
          程序执行catch块中return之前（包括return语句中的表达式运算）代码；
          再执行finally块，因为finally块中有return所以提前退出。
情况6 :try{ return;}catch(){return;} finally{return;}
          程序执行try块中return之前（包括return语句中的表达式运算）代码；
          有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；
                       则再执行finally块，因为finally块中有return所以提前退出。
    无异常：则再执行finally块，因为finally块中有return所以提前退出。

最终结论 ：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
                  如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，
                  编译器把finally中的return实现为一个warning。

发表于 2016-09-05 22:10:06 回复(12)

melon

程序先执行try块中return之前（包括return语句中的表达式运算）的代码；再执行finally块，最后执行try块中的return; 而 finally块之后的return语句，因为程序在try块中已经return了，所以不再执行。

发表于 2015-08-13 14:51:51 回复(8)

蓄意碎碎

先执行finally ,在执行return

发表于 2015-08-13 14:06:37 回复(0)

不思进取的我

肯定会有人会对方法内部的return 0为什么没有在编译期间抛出不可达的语句的错误感到疑惑。这是因为第一个return是写在try块中的，因此编译器推断这句可能得不到执行。所以最后的return 0是可能达到的。

发表于 2017-04-29 18:48:11 回复(2)

菩提旭光

应该选c。。先执行return缓存起来,再执行finally模块，然后再执行return。

发表于 2015-08-17 14:06:17 回复(1)

消失的极光

关于和是，这里应该是sysout的一个小考察～sysout会先处理参数得到一个完整的字符串，则在处理过程中先执行输出了"final语句块"，然后再去return,最后得到一个完整的字符串再进行在控制台的输出。本人观点。

发表于 2016-06-01 01:05:53 回复(0)

牛仔very的忙

答案是C

对于try块中的return，先计算return 后面的表达式，缓存结果

跳到finally语句块中执行，如果finally语句块中有return语句，则不会再去执行try中的语句。

如果finally中没有return语句，则会再次去try语句块中执行return

编辑于 2015-08-21 17:21:55 回复(3)

vivizhang

在eclipse中运行知道运行的顺序了：try里面的语句(return语句前的所有语句)--->finally里面的语句（全部执行，如果有return语句，就返回return语句，try中的return语句将不执行，如果没有，就回到try中的return语句执行）---->最后是main中的打印语句。至于为什么不先打印“和是”，我也不知道原因。很遗憾！有没有知道的牛客留个言吧！

发表于 2016-04-24 15:48:30 回复(1)

牛客447933号

怎么也应该先输出"和是"吧

发表于 2015-09-16 19:32:02 回复(3)

anhoulin

http://www.cnblogs.com/xiohao/p/4278405.html

想弄明白的童鞋，去看这篇博文，感觉还行

对于上面程序而言：

先执行try块中的语句，return a+b;，系统把返回的a+b=43，先保存到栈内存中，但并不是马上返回。

然后catch捕获try快中异常，然后执行finally块中的打印语句，

最后，finally块中语句执行结束，系统再把栈内存中的返回值返回。

所以选择c

编辑于 2016-06-17 09:39:45 回复(0)

牛客549776527号

finally return会刷新栈的值，没有return，只用栈保存的值

发表于 2021-12-29 08:39:47 回复(0)

Feos

个人理解，finally 会卡住try里面的return，虽然会执行return里的语句，但结果就是出不去。假设finally里也有return，那么会以该return为准，因为会覆盖结果。因此执行流程为，1.Syso (和是：) 无法输出，未执行完。2.Syso (和是：add ())调用了add()方法，方法中的finally打印了“finally 语句块”，并得到结果43输出：finally 语句块3.Syso (和是：add())执行完输出：和是：43最终结果：finally语句块和是：43

发表于 2021-08-02 01:29:38 回复(0)