try中return某值，而finally中修改了这个值

try中return某值，而finally中修改了这个值

首先上结论：

• try{…} finally{…} return
  
  • 顺序执行
• try{ return } finally{…} return
  
  • finally修改基本类型，则不影响返回值
  • finally修改非基本类型，影响返回值
• try{ return } finally{ return }
  
  • try的return表达式执行，但不返回。在finally中返回

本文按以下三方面进行实验

• try中无return、finally中无return
• try中有return、finally中无return
• try中有return、finally中有return
• 最后总结

1、try中无return，finally中无return

此时程序就是顺序执行，当执行func(10)时，首先执行try{…}，然后执行finally{…}，最终的返回值是12

public static int func(int x) {
    try {
        x++;
    }catch(Exception e) {

    }finally {
        x++;
    }
    return x;
}

2、try中有return，finally中无return

• 如果发生改变的是基本类型（byte、short、int、long等），finally虽然执行，但是不影响 最终返回值
• 如果发生改变的是非基本类型（对象），则finally影响返回的值

Example1：基本类型

public static int func(int x) {
    try {
        x++;    // 执行顺序 1
        return x++; // 执行顺序 2
    }catch(Exception e) {

    }finally {
        System.out.println("x = " + x); // x = 3
        System.out.println("finally"); //执行顺序 3
        x += 2;
    }

    // 下面的代码不执行，因为在try中就return了
    System.out.println("return"); 
    return x;
}

上面代码执行的顺序是：

x++
return x++ ，不返回而是执行x++，并将结果缓存起来。等到finally执行完后再返回。
System.out.println(“finally”);

Example2：非基本类型

class A {
    int val = 0;
}

public static A func(A a) {
    try {
        a.val = 1; // 执行顺序 1
        return a;  // 执行顺序 2
    }catch(Exception e) {

    }finally {
        a.val = 2; // 执行顺序 3
    }

    // 下面的代码不执行
    System.out.println("return");
    return a;
}

// Test case
A a = new A();
System.out.println(func(a).val); // 2

上面代码执行的顺序是：

a.val = 1
return a; // 先不返回
a.val = 2;

3、try中有return，finally中有return

Example1：基本类型

public static int func(int x) {
    try {
        return x++; // 执行顺序 1
    }catch(Exception e) {

    }finally {
        System.out.println("finally"); // 执行顺序 2
        x += 2; // 执行顺序 3
        return x; // 执行顺序 4
    }
}

执行func(10)的结果是：13
首先执行try中 return的x++，但是结果不返回，而是缓存起来。
然后执行finally中的语句，最后在finally中返回。

Example2：非基本类型

class A {
    int val = 0;
}

public static A func(A a) {
    try {
        a.val++;  // 执行顺序 1
        return a;
    }catch(Exception e) {

    }finally {
        System.out.println("finally"); // 执行顺序 2
        a.val++; // 执行顺序 3
        return a; // 执行顺序 4
    }
}

与基本类型相似，首先执行try中 a.val++，但是结果不返回，而是缓存起来。
然后执行finally中的语句，最后在finally中返回。

总结一下：

• try{…} finally{…} return

  • 顺序执行

• try{ return } finally{…} return

  • finally修改基本类型，则不影响返回值
  • finally修改非基本类型，影响返回值

• try{ return } finally{ return }

  • try的return表达式执行，但不返回。在finally中返回