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

一、前言

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

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.<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）