一、前言
前些天参加面试的时候有一道题：
public class test {
public static void main(String[] args){
try {
return;
}
finally{
System.out.println("finally...");
}
}
}
以上程序的执行结果是什么？
当时觉得finally块肯定会被执行到的，而这段程序在try块里就已经返回了，所以选了“编译出现错误”这个选项，回来之后验证了一下，结果是输出“finally…”，越发觉得这个问题很有趣。
二、剖析
1. 从字节码分析
为了更好的说明问题，选用一篇博客里的例子[1]进行说明，源码：
public class Test {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
try {
t = "try";
return t;
} catch (Exception e) {
t = "catch";
return t;
} finally {
t = "finally";
}
}
public static void main(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 final java.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_0
3: ldc #3 // String try
5: astore_0
6: aload_0
7: astore_1
8: ldc #4 // String finally
10: astore_0
11: aload_1
12: areturn
13: astore_1
14: ldc #6 // String catch
16: astore_0
17: aload_0
18: astore_2
19: ldc #4 // String finally
21: astore_0
22: aload_2
23: areturn
24: astore_3
25: ldc #4 // String finally
27: astore_0
28: aload_3
29: athrow
Exception table:
from to target type
3 8 13 Class java/lang/Exception
3 8 24 any
13 19 24 any
LineNumberTable:
line 5: 0
line 8: 3
line 9: 6
line 14: 8
line 10: 13
line 11: 14
line 12: 17
line 14: 19
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 13
locals = [ 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块里面修改的是可变的对象
class myObject{
private int value = 0;
public myObject(int value){
this.value = value;
}
public void setValue(int value){
this.value = value;
}
public void print(){
System.out.println("obj:" + this + ",value:" + value);
}
}
public class Test {
@SuppressWarnings("finally")
public static final myObject test() {
myObject myObj = null;
try {
myObj = new myObject(1);
System.out.println("in try block");
myObj.print();
return myObj;
} catch (Exception e) {
myObj.setValue(2);
return myObj;
} finally {
myObj.setValue(3);
}
}
public static void main(String[] args) {
myObject newObj = test();
System.out.println("after return");
newObj.print();
}
}
输出：
in try block
obj:myObject@15db9742,value:1
after return
obj:myObject@15db9742,value:3
在这个例子中，即使myObj会赋值给myObj’，然而他们都指向同一个对象，因此在finally块中对这个对象的修改当然反映到myObj’中。
3. try和finally块中都有return语句
还是用String的例子，不过finally语句增加了return语句
public class Test {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
try {
t = "try";
return t;
} catch (Exception e) {
t = "catch";
return t;
} finally {
t = "finally";
return t;
}
}
public static void main(String[] args) {
System.out.print(Test.test());
}
}
最后输出：
finally
可见这种情况，执行完finally之后就直接返回了。
4. catch语句被执行的情况并且有return语句
public class Test {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
try {
t = "try";
Integer.parseInt(null);
return t;
} catch (Exception e) {
t = "catch";
return t;
} finally {
t = "finally";
}
}
public static void main(String[] args) {
System.out.print(Test.test());
}
}
最后输出：
catch
可见try和catch语句里都存在使用中间变量的情况。
5. catch块中抛出异常的情况
public class Test {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
try {
t = "try";
Integer.parseInt(null);
return t;
} catch (Exception e) {
t = "catch";
Integer.parseInt(null);
return t;
} finally {
t = "finally";
}
}
public static void main(String[] args) {
System.out.print(Test.test());
}
}
输出：
Exception in thread "main" java.lang.NumberFormatException: null
at 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 class Test {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
try {
t = "try";
return t;
} catch (Exception e) {
t = "catch";
return t;
} finally {
t = "finally";
String.valueOf(null);
return t;
}
}
public static void main(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.
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中的其他操作，直接向上抛出异常。
四、参考
1. java中关于try、catch、finally中的细节分析
2. 从Java代码到字节码（1）