Java异常类学习中遇到的: return与finally执行顺序问题

　　我们经常会使用try/catch/finally语句块。当然，return关键字使用也是很平常的事，但是不知道大家有没有注意个这样一个问题。当在try语句块里面使用return语句，在finally里面去修改return所要返回的内容会出现什么情况。首先，我们知道return是结束方法的标志，一旦方法执行到return语句就将返回不再往下执行。其次，我们也知道，finally里面的语句是无论方法怎样执行，最后都要执行finally里面的语句。那么究竟是先执行return还是finally呢？下面通过两个小实验来解决这个问题。

先说结论:

　　无论程序从try或catch中返回，finally总会被执行。并且finally语句是在return语句执行之后、返回之前执行的。

首先看第一个例子：

public class TestTryCatch {
    public static void main(String[] args)
    {
        TestTryCatch test = new TestTryCatch();
        System.out.println(test.fun());
    }

    public int fun()
    {
        int i = 10;
        try
        {
            //doing something

            return i;
        }catch(Exception e){
            return i;
        }finally{
            i = 20;
        }
    }
}

输出结果：10

　　Ok很简单的一个例子，创建了一个方法fun，在方法里使用try/catch语句，方法要求返回值类型为int型。在try里面放回i，这个时候是10，但是在finally里面将i值修改为20。我们看到结果是10，好像是return先执行。那么接下来再看另一个例子：

public class TestTryCatch {
    public static void main(String[] args)
    {
        TestTryCatch test = new TestTryCatch();
        System.out.println(test.fun());
    }

    public StringBuilder fun()
    {
        StringBuilder s = new StringBuilder("Hello");
        try
        {
            //doing something
            s.append("World");

            return s;
        }catch(Exception e){
            return s;
        }finally{
            s.append("finally");
        }
    }
}

输出结果：HelloWorldfinally

　　看结果似乎有点出乎意料了，因为这次finally里面修改的内容生效了。看代码其实差别不大，只是把返回值类型修改为StringBuilder了。那么这是为什么呢？下面就为大家解释一下其中到底是怎么执行的。

　　首先，拿第一个例子来说，可以在main方法里实现这样一条语句：int result = test.fun();我们知道这样做是没有问题的，但是大家都知道“=”号赋值是常量赋值。但是，方法的存放地址和常量的存放地址是不一样的，方法存放在堆区的, 在实例对象被声明后会生成变量地址。上面我们把一个方法赋值给一个int型也没有报错，那是因为在声明方法是我们声明了返回值类型。那么编译器就会在代码的最前端预留一段返回值类型的内存。执行return的时候，就会把返回的内容写入到这段内存中

注:　　变量的声明

　　　　声明一个对象类型的变量时，同样会在栈中为该变量分配一块内存，不同的是：这块内存用来存储一个对象的引用。
　　变量的赋值
　　　　当使用new关键字创建一个对象，会在堆中分配空间来存储此对象，通过赋值号 “=” 可以将new关键字创建出的对象的引用存储在相应对象类型的变量中。
　　　　当使用赋值号将一个对象类型的变量赋值给另一个变量时，由于该变量存储的是一个对象的引用，因此实际上是将引用赋值给了另一个变量。此时，可以简单的描述为：这两个变量引用了同一个对象。

　　这样，执行“=”号赋值的时候，就能在内存中匹配到相同的类型。赋值便能成功。

　　弄清楚上面的道理之后，再来解释最开始提出的问题就容易多了。在执行了return之后，返回的值已经被写入到那段内存中了，finally再修改i的值，只是修改了后面代码段的i值，对返回段内存没有影响。至于第二个例子，再看下面这张图你就会明白。

　　我们可以看到，当返回值不是基本数据类型的时候，其是指向一段内存的，return将返回段指向一段内存，但是代码段的s依然是指向的同一段内存地址，所以当s修改它指向内存中的值的时候，其实也就修改了返回段指向内存中的值，所以最终的值改变了。

总结:

　　到底返回值变不变可以简单的这么记忆：当finally调用的任何可变API(引用类型的变量)，会修改返回值；当finally调用任何的不可变API(常量)，对返回值没有影响。

　　总结一下：其实return与finally并没有明显的谁强谁弱。在执行时，是return语句先把返回值写入但内存中，然后停下来等待finally语句块执行完，return再执行后面的一段，也就是return会分成两段来执行。

=================================分割线=====================================

还有一种是return在try、catch、finally中嵌套

若是finally中有return，则将会以finally中的return为准，try/catch中的return将会unreached。

public class TryTest{
    public static void main(String[] args){
        System.out.println(test());
    }
 
    private static int test(){
        int num = 10;
        try{
            System.out.println("try");
            return num += 80;
        }catch(Exception e){
            System.out.println("error");
        }finally{
            if (num > 20){
                System.out.println("num>20 : " + num);
            }
            System.out.println("finally");
            num = 100;
            return num;
        }
    }

输出结果为: 
try
num>20 : 90
finally
100