Java finally语句是在try或catch的retrurn之前还是之后执行

若try或catch中没有return语句，则按正常执行流，从上到下，finally里的所有修改都生效。

这里讨论的是try或catch里有return或throw语句的情形，此情形比较让人迷惑。

总结如下：

finally语句在try或catch的return或throw语句执行之后返回之前执行 且 finally里的语句不影响try或catch中已经确定的返回值（但能改变try或catch中引用对象里的成员，这跟final修饰的效果很像），除非finally里也有return或者throw等终止方法的语句，则就不会跳回try或catch执行，直接停止。

一般不建议在finally里return，在Eclipse里会警告 finally block does not complete normally 。

示例：

0、try中没有return语句，finally的修改生效

class FinallyTest0 {
    public static void main(String[] args) {
        System.out.println(test0());
    }

    public static int test0() {
        int b = 20;
        try {
            System.out.println("try block");
            
            b += 80;
        } catch (Exception e) {
            b += 15;
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            b += 50;
        }
        return b;
    }
}

执行结果：

try block
finally block
b>25, b = 100
150

此情形很简单，无须多言。当然，将return b;放在finally里的末尾效果也一样。

1、finally语句在try中return语句执行之后且返回之前执行的

class FinallyTest1 {
    public static void main(String[] args) {
        System.out.println(test1());
    }

    public static int test1() {
        int b = 20;
        try {
            System.out.println("try block");
            return b += 80;
        } catch (Exception e) {
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
        }
        return b;
    }
}

执行结果：

try block
finally block
b>25, b = 100
100

说明return语句已经执行了再去执行finally语句，不过并没有直接返回，而是等finally语句执行完了再返回结果。此外，从这也可以看出，程序执行完finally后就回到try中返回了，程序最后的return b并不会执行。

另一个示例：

class FinallyTest1 {
    public static void main(String[] args) {
        System.out.println(test11());
    }

    public static String test11() {
        try {
            System.out.println("try block");
            return test12();
        } finally {
            System.out.println("finally block");
        }
    }

    public static String test12() {
        System.out.println("return statement");
        return "after return";
    }
}

执行结果：

try block
return statement
finally block
after return

说明try中的return语句先执行了但并没有立即返回，等到finally执行结束后再返回。

2、finally块中的return语句会覆盖try块中的return返回

class FinallyTest2 {
    public static void main(String[] args) {
        System.out.println(test2());
    }

    public static int test2() {
        int b = 20;
        try {
            System.out.println("try block");
            return b += 80;
        } catch (Exception e) {
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            return 200;
        }
        // return b;//不可达
    }
}

执行结果：

try block
finally block
b>25, b = 100
200

说明finally里的return直接返回了，不管try中是否还有返回语句。

3、try中要返回的值不因finally里的修改而改变

class FinallyTest3 {
    public static void main(String[] args) {
        System.out.println(test3());
    }

    public static int test3() {
        int b = 20;
        try {
            System.out.println("try block");
            return b += 80;
        } catch (Exception e) {
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            b = 150;
        }
        return 2000;
    }
}

执行结果：

try block
finally block
b>25, b = 100
100

说明finally里的修改不改变try里的返回值。

 

另一个示例：（虽然对象的内容变了，但引用的是哪个对象并没变）

class FinallyTest3 {
    public static void main(String[] args) {
        System.out.println(getMap().get("KEY").toString());
    }

    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("KEY", "INIT");
        try {
            map.put("KEY", "TRY");
            return map;
        } catch (Exception e) {
            map.put("KEY", "CATCH");
        } finally {
            map.put("KEY", "FINALLY");
            map = null;
        }
        return map;
    }
}

执行结果：

FINALLY

变量map是对象的引用，虽然finally中map.put使得引用的对象的内容变了，但对引用变量map的修改map=null并没对return的返回值起作用（返回值没变为null）。

注意体会 对引用的修改 和 对引用对象的修改 两者的区别，这与final修饰一个引用变量的情形相似，虽然此时引用变量不可更改，但却可以修改引用对象里的内容。

 

如果把最后的 return map; 放到finally里末尾，则由上面的2知try里的return的值变了。示例如下：

class FinallyTest3 {
    public static void main(String[] args) {
        System.out.println(getMap().get("KEY").toString());
    }

    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("KEY", "INIT");
        try {
            map.put("KEY", "TRY");
            return map;
        } catch (Exception e) {
            map.put("KEY", "CATCH");
        } finally {
            map.put("KEY", "FINALLY");
            map = null;
            return map;
        }
        // return map;
    }
}

结果：（由于try里返回了null，导致后续访问异常）
Exception in thread "main" java.lang.NullPointerException
    at buaa.act.ucar.imtg.main.FinallyTest6.main(Test.java:23)

4、catch中的情形与try的一样

在try块发生异常的情况下其里面的return语句不会被执行，转到catch，catch里的执行情形与上述try的一样。

示例1及结果（对应0）：

class FinallyTest4 {
    public static void main(String[] args) {
        System.out.println(test4());
    }

    public static int test4() {
        int b = 20;
        try {
            System.out.println("try block");
            b = b / 0;
            return b += 80;
        } catch (Exception e) {
            b += 15;
            System.out.println("catch block");
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            b += 50;
        }
        return b;
    }
}

try block
catch block
finally block
b>25, b = 35
85

在try里return之前发生了除0异常，所以try中的return不会被执行到，而是接着执行捕获异常的catch语句和最终的finally语句，此时两者对b的修改都影响了最终的返回值。

示例2及结果（对应1、3）：

class FinallyTest4 {
    public static void main(String[] args) {
        System.out.println(test4());
    }

    public static int test4() {
        int b = 20;
        try {
            System.out.println("try block");
            b = b / 0;
            return b += 80;
        } catch (Exception e) {
            System.out.println("catch block");
            return b += 15;
        } finally {
            System.out.println("finally block");
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
            b += 50;
        }
    }
}

try block
catch block
finally block
b>25, b = 35
35

说明了发生异常后，catch中的return语句先执行，确定了返回值后再去执行finally块，执行完了catch再返回，finally里对b的改变对返回值无影响，原因同前面try的一样。

示例3及结果（对应2）：在finally里末尾加上return b;则最后打印出的b值为85。

 

参考资料：http://www.cnblogs.com/lanxuezaipiao/p/3440471.html