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