一、前言

前些天参加面试的时候有一道题：

public classtest {

public static voidmain(String[] args){try{return;

}finally{

System.out.println("finally...");

}

}

}

以上程序的执行结果是什么？

当时觉得finally块肯定会被执行到的，而这段程序在try块里就已经返回了，所以选了“编译出现错误”这个选项，回来之后验证了一下，结果是输出“finally…”，越发觉得这个问题很有趣。

二、剖析

1. 从字节码分析

为了更好的说明问题，选用一篇博客里的例子[1]进行说明，源码：

public classTest {

@SuppressWarnings("finally")public static finalString test() {

String t= "";try{

t= "try";returnt;

}catch(Exception e) {

t= "catch";returnt;

}finally{

t= "finally";

}

}public static voidmain(String[] args) {

System.out.print(Test.test());

}

}

按照一般的思路，首先程序执行try语句块，把变量t赋值为try，由于没有发现异常，接下来执行finally语句块，把变量t赋值为finally，然后return t，则t的值是finally，最后t的值就是finally，程序结果应该显示finally，但是实际结果为try。为什么会这样，我们不妨先看看这段代码编译出来的class对应的字节码，看虚拟机内部是如何执行的。

我们用javap -verbose Test 来显示目标文件(.class文件)字节码信息。

系统运行环境：win7 64位

jdk信息：java version "1.8.0_05"，Java(TM) SE Runtime Environment (build 1.8.0_05-b13)，Java HotSpot(TM) 64-Bit Server VM (build 25.5-b02, mixed mode)

编译出来的字节码部分信息，我们只看test方法，其他的先忽略掉：

public static finaljava.lang.String test();

descriptor: ()Ljava/lang/String;

flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL

Code:

stack=1, locals=4, args_size=0

0: ldc #2 //String

2: astore_03: ldc #3 //String try

5: astore_06: aload_07: astore_18: ldc #4 //String finally

10: astore_011: aload_112: areturn13: astore_114: ldc #6 //String catch

16: astore_017: aload_018: astore_219: ldc #4 //String finally

21: astore_022: aload_223: areturn24: astore_325: ldc #4 //String finally

27: astore_028: aload_329: athrow

Exception table:

from to target type3 8 13 Class java/lang/Exception3 8 24any13 19 24any

LineNumberTable:

line5: 0line8: 3line9: 6line14: 8line10: 13line11: 14line12: 17line14: 19StackMapTable: number_of_entries= 2frame_type= 255 /*full_frame*/offset_delta= 13locals= [ class java/lang/String ]

stack= [ class java/lang/Exception ]

frame_type= 74 /*same_locals_1_stack_item*/stack= [ class java/lang/Throwable ]

观察Code部分：

第[0-2]行，给第0个变量赋值“”，也就是String t=""；

第[3-5]行，也就是执行try语句块 赋值语句 ，也就是 t = "try";

第[6-7]行，重点是第7行，把第t对应的值"try"赋给第1个变量，但是这里面第1个变量并没有定义这个比较奇怪；

第[8-10] 行，对第0个变量进行赋值操作，也就是t="finally"；

第[11-12]行，把第1个变量对应的值返回；

通过字节码，我们知道，在return之前，虚拟机会创建一个中间变量，我们暂时可以称为t’,然后把t的值赋值给t’，接下来去执行finally块的内容，最后返回t’，所以即使在finally块里修改了t，但是return返回的是t’，所以最后输出的是t’的内容，如下图所示：

2. 如果try和finally块里面修改的是可变的对象

classmyObject{private int value = 0;public myObject(intvalue){this.value =value;

}public void setValue(intvalue){this.value =value;

}public voidprint(){

System.out.println("obj:" + this + ",value:" +value);

}

}public classTest {

@SuppressWarnings("finally")public static finalmyObject test() {

myObject myObj= null;try{

myObj= new myObject(1);

System.out.println("in try block");

myObj.print();returnmyObj;

}catch(Exception e) {

myObj.setValue(2);returnmyObj;

}finally{

myObj.setValue(3);

}

}public static voidmain(String[] args) {

myObject newObj=test();

System.out.println("after return");

newObj.print();

}

}

输出：

in tryblock

obj:myObject@15db9742,value:1afterreturnobj:myObject@15db9742,value:3

在这个例子中，即使myObj会赋值给myObj’，然而他们都指向同一个对象，因此在finally块中对这个对象的修改当然反映到myObj’中。

3. try和finally块中都有return语句

还是用String的例子，不过finally语句增加了return语句

public classTest {

@SuppressWarnings("finally")public static finalString test() {

String t= "";try{

t= "try";returnt;

}catch(Exception e) {

t= "catch";returnt;

}finally{

t= "finally";

returnt;

}

}public static voidmain(String[] args) {

System.out.print(Test.test());

}

}

最后输出：

finally

可见这种情况，执行完finally之后就直接返回了。

4. catch语句被执行的情况并且有return语句

public classTest {

@SuppressWarnings("finally")public static finalString test() {

String t= "";try{

t= "try";

Integer.parseInt(null);returnt;

}catch(Exception e) {

t= "catch";returnt;

}finally{

t= "finally";

}

}public static voidmain(String[] args) {

System.out.print(Test.test());

}

}

最后输出：

catch

可见try和catch语句里都存在使用中间变量的情况。

5. catch块中抛出异常的情况

public classTest {

@SuppressWarnings("finally")public static finalString test() {

String t= "";try{

t= "try";

Integer.parseInt(null);returnt;

}catch(Exception e) {

t= "catch";

Integer.parseInt(null);returnt;

}finally{

t= "finally";

}

}public static voidmain(String[] args) {

System.out.print(Test.test());

}

}

输出：

Exception in thread "main" java.lang.NumberFormatException: nullat java.lang.Integer.parseInt(Integer.java:542)

at java.lang.Integer.parseInt(Integer.java:615)

at Test.test(Test.java:12)

at Test.main(Test.java:20)

执行过程大概是，执行try块，Integer.parseInt(null)语句抛出异常，进入catch语句，然后又抛出异常，然后执行finally块，对t进行赋值，因为finally没有返回，所以执行完之后，catch把异常抛出。

如果finally块中有return语句呢，在finally块最后加多一条语句”return t;”，最后输出：

finally

6. finally块中抛出异常

public classTest {

@SuppressWarnings("finally")public static finalString test() {

String t= "";try{

t= "try";returnt;

}catch(Exception e) {

t= "catch";returnt;

}finally{

t= "finally";

String.valueOf(null);returnt;

}

}public static voidmain(String[] args) {

System.out.print(Test.test());

}

}

输出：

Exception in thread "main" java.lang.NullPointerException[Finished in 1.1s with exit code 1]

at java.lang.String.(String.java:166)

at java.lang.String.valueOf(String.java:2993)

at Test.test(Test.java:14)

at Test.main(Test.java:20)

可见执行到finally块，产生异常之后会终止当前的其他操作，向上抛出异常。

三、小结

try，catch，finally语句中，如果在try/catch块中存在return语句，finally块没有return语句，try/catch块会产生一个临时变量(t’)存储return 语句中的变量(t)，如果这个变量类型是值类型或者不可变对象，则在finally块中对变量t的修改不会影响到try/catch中返回的结果；如果是可变对象类型，则结果会影响；

如果finally块中有return语句，则try和catch中的return语句都会忽略；

如果finally块中抛出异常，则停止try…catch…finally中的其他操作，直接向上抛出异常。

四、参考