• 正常执行流程：

try执行，遇到异常就跳到catch执行（以使得程序不会崩溃）；

不管有没有异常catch，最后都执行finally

若try块中return 可达， return语句（如：return x=x+1;）：

1. 对x执行运算x=x+1 （若有运算）
2. 复制一个变量x给try的return语句（按值复制：基本类型就是值本身，对象就是地址值）
3. 但return语句并不马上返回，控制权转移到finally块中执行： （1）若finally中无return语句：finally执行完后，try块执行return语句返回之前复制的变量x（基本类型就是值本身，对象就是地址值）（所以：若x为基本类型，fianlly中改变x对最终return结果无效；若x为对象类型，按地址值传递可以改变x的最终return结果）    （2）若finally中有return语句：执行后直接返回（即“覆盖try中return语句”：try中return语句不再返回）

若try中return 不可达（exception 在return前出现）：

    exception出现后控制权直接转到catch 块（即try中 exception之后的语句<包括return>不会执行），最后到finally块（catch到finally中流程与上面try到finally中流程相同）

 

 

• finally不执行的特殊情况：

 

• A return statement in the finally block is a bad idea：

By doing a return from the finally block, you suppress the exception entirely.（finally 中有return ，try,catch的 return throw都不会再被调用）

Running the method above will return a “43” and the exception in the try block will not be thrown. This is why it is considered to be a very bad idea to have a return statement inside the finally block.

 

（参考资料：http://www.programmerinterview.com/index.php/java-questions/will-finally-run-after-return/）

 

---

例子解释：

 

1. If the return in the try block is reached, it transfers control to the finally block, and the function eventually returns normally (not a throw).
2. If an exception occurs, but then the code reaches a return from the catch block, control is transferred to the finally block and the function eventually returns normally (not a throw).
3. In your example, you have a return in the finally, and so regardless of what happens, the function will return 34, because finally has the final (if you will) word.

1. publicclassFinallyTest1{
3.     publicstaticvoid main(String[] args){
4.         System.out.println(test1());
5.     }
7.     publicstaticint test1(){
8.         int b =20;
9.         try{
10.             System.out.println("try block");
11.             return b +=80;
12.         }
13.         catch(Exception e){
14.             System.out.println("catch block");
15.         }
16.         finally {
17.             System.out.println("finally block");
18.             if(b >25){
19.                 System.out.println("b>25, b = "+ b);
20.             }
21.         }
22.         return b;
23.     }
24. }

运行结果：

1. try block
2. finally block
3. b>25, b =100
4. 100

1. publicclassTest{
2.  
3.     publicstaticvoid main(String[] args){
4.  
5.         System.out.println(test1());
6.     }
7.  
8.     publicstaticint test1(){
9.         int b =20;
10.  
11.         try{
12.             int a =1/0;//触发异常
13.             System.out.println("try block");//不会被执行
14.             return b +=80;//不会被执行
15.         }
16.         catch(Exception e){
17.             System.out.println("catch block");
18.             return b +=180;//最后在此返回
19.         }
20.         finally {
21.             System.out.println("finally block");
22.             if(b >25){
23.                 System.out.println("b>25, b = "+ b);
24.             }
25.         }
26. //        return b;
27.     }
28.  
29. }

执行结果：

1. catch block
2. finally block
3. b>25, b =200
4. 200

 

1. publicclassTest{
2.  
3.     publicstaticvoid main(String[] args){
4.         System.out.println(getMap().get("KEY").toString());
5.     }
6.  
7.     publicstaticMap<String,String> getMap(){
8.         Map<String,String>map=newHashMap<String,String>();
9.         map.put("KEY","INIT");
10.  
11.         try{
12.             map.put("KEY","TRY");
13.             returnmap;//return在控制权转移到finally前：复制了一个map对象的地址值（对象按地址值传递）
14.         }
15.         catch(Exception e){
16.             map.put("KEY","CATCH");
17.         }
18.         finally {
19.             map.put("KEY","FINALLY");//根据对象地址值修改对象内容（按地址值传递），因此会影响try中return返回的对象内容
20.             map= null;//map为null即不再指向该对象，
21.             // 但由于前面return复制了一个对象的引用（地址值），而对象是被分配在堆中的，只要有引用指向这个对象，系统就不会回收此对象， 所以此处map = null 并不会影响最后try中return返回对象内容
22.         }
23.  
24.         returnmap;
25.     }
26.  
27. }

执行结果：

1. FINALLY

• 在catch中含有return+基本类型情况（分析跟在try中含有return情况一样）：

1. publicclassTest{
2.  
3.     publicstaticvoid main(String[] args){
4.         System.out.println(getMap().get("KEY").toString());
5.     }
6.  
7.     publicstaticMap<String,String> getMap(){
8.         Map<String,String>map=newHashMap<String,String>();
9.         map.put("KEY","INIT");
10.  
11.         try{
12.             int a =1/0;//触发异常
13.             map.put("KEY","TRY");//不会被执行
14.             returnmap;//不会被执行
15.         }
16.         catch(Exception e){
17.             map.put("KEY","CATCH");
18.             returnmap;//return在控制权转移到finally前：复制了一个map对象的地址值（对象按地址值传递）
19.         }
20.         finally {
21.             map.put("KEY","FINALLY");//根据对象地址值修改对象内容（按地址值传递），因此会影响catch中return返回的对象内容
22.             map= null;//map为null即不再指向该对象，
23.             // 但由于前面return复制了一个对象的引用（地址值），而对象是被分配在堆中的，只要有引用指向这个对象，系统就不会回收此对象，
24.             // 所以此处map = null 并不会影响最后catch中return返回对象内容
25.         }
26.  
27. //        return map;
28.     }
29.  
30. }

执行结果：

1. FINALLY

 

1. publicclassTest{
2.  
3.     publicstaticvoid main(String[] args){
4.  
5.         System.out.println(test2());
6.     }
7.  
8.     publicstaticint test2(){
9.         int b =20;
10.  
11.         try{
12.             System.out.println("try block");
13.             return b +=80;
14.         }catch(Exception e){
15.             System.out.println("catch block");
16.         } finally {
17.             System.out.println("finally block");
18.             if(b >25){
19.                 System.out.println("b>25, b = "+ b);
20.             }
21.             return200;
22.         }
23.         // return b;
24.     }
25.  
26. }

执行结果：

1. try block
2. finally block
3. b>25, b =100
4. 200