深入剖析java的try…catch…finally语句

时间:2022-01-28 21:00:42

一、前言

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

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’的内容,如下图所示:

深入剖析java的try…catch…finally语句

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.<init>(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中的其他操作,直接向上抛出异常。

四、参考

1. java中关于try、catch、finally中的细节分析

2. 从Java代码到字节码(1)