2、为什么要用finally
先看一个没有finally的异常处理try-catch语句：
假设count为要使用到的资源，并且用完要求释放此资源。那么我们可以把释放资源的语句放到try-catch后执行，当前的程序不管是在执行完try语句块还是catch语句块，都会顺序执行到下面释放资源的语句。
int count = 0;  //初始化资源
try{
  count++;
  if(count == 1) throw new Exception("Exception in try");
}catch(Exception e){
  System.out.println("catch block");
}
count = 0; //释放资源

但是，如果在try或catch中有多条return语句，那么在每条return语句之前，都要先执行释放资源的语句：
public void f() throws Exception {
 int count = 0;  //初始化资源
 try{
   doSomething;
   statementMayCauseException; 

//可能会抛出异常的语句，若异常没有被catch，则直接抛出，也不会执行到try-catch下面的语句，因为这个异常被系统处理就是打印了异常栈的信息之后就结束了这个程序，也就是结束了这个进程。
   doSomething;
   if(count == 1) throw new Exception1("E1 in try");
   if(count == 2) throw new Exception2("E2 in try");
 }catch(Exception1 e){
   count = 0; //释放资源
   throw e;  //再次把异常抛出，让上一级捕获。此时将不会执行catch外的语句，所以要先释放资源
 }catch(Exception2 e){
  count = 0; //释放资源
  return; //返回了，也不会执行catch外的语句，所以要先释放资源
 }
 count = 0;

//释放资源，其实count=0程序不会执行这里的因为在执行期间先获得了前面的那个return语句所以后面就不会执行了。
}
这样，就需要在每一个可能返回的地方，以及每一个可能出现异常而导致程序跳转的地方，考虑如何释放资源，导致复杂和冗余。

所以，需要finally语句。
把资源释放或状态还原的代码放到finally块中，可以保证在try和catch语句执行完后，一定会执行finally语句块，而不用考虑各种复杂的跳转情况。
1、int count = 0;
try{
 count++;
 if(count == 1)throw new Exception();
}catch(Exception e){
}finally{
 count = 0;
}

2.finally什么时候执行
finally在return语句之后，跳转到上一级程序之前执行。

 

[java] view plain copy print?
 1     public class Test {  
 2       
 3         public static void main(String[] args) {  
 4             System.out.println(test());  
 5         }  
 6       
 7         public static String test() {  
 8             try {  
 9                 System.out.println("try block");  
10                 return test1();  
11             } finally {  
12                 System.out.println("finally block");  
13                 // return "finally";  
14             }  
15         }  
16       
17         public static String test1() {  
18             System.out.println("return statement");  
19             return "after return";  
20         }  
21     }


结果：
try block
return statement
finally block
after return

 


分析：
1.try语句块，return test1()，则调用test1方法
2.test1()执行后返回"after return"，返回值"after return"保存在一个临时区域里
3.执行finally语句块。若finally语句有返回值，则此返回值将替换掉临时区域的返回值
4.再将临时区域的返回值送到上一级方法中。

try、catch、finally 这个过程也就是这样，如果try catch finally 都有return：

1、在没有异常的情况下，try 中的返回值先保存到临时区域里在去执行finally ，这个finally 有返回值，这个返回值将之前try中的保存到临时区域的值用返回的这个值替换，再将这个临时区域中的值返回给上一级方法。

2、如果有异常，则执行catch中的代码，这里的return 将返回一个返回值放到临时区域，再去执行finally ，这个finally有返回值，这样就将catch中存在临时区域中的值用这个finally 返回的值替换掉，在将这个临时区域的值返回给上一级方法。

 

如果finally语句有返回值，则此返回值将会替换掉临时区域原有的值。
参考：
《thinking in Java》

 

2，验证finally真正执行顺序

 

[java] view plain copy print?
 1     import java.io.FileInputStream;  
 2       
 3     public class Test1 {  
 4         public static void main(String[] args) {  
 5             Test1 m = new Test1();  
 6             System.out.println(m.amethod());  
 7         }  
 8       
 9         public int amethod() {  
10             try {  
11                 // 1，抛出异常  
12                 FileInputStream dis = new FileInputStream("test1.txt");  
13             } catch (Exception ex) {  
14                 // 2.catch捕获异常，并执行  
15                 System.out.println("No such file found");  
16                 // 4,return 返回  
17                 return -1;  
18             } finally {  
19                 // 3.finally一定会在return之前执行。（准确说，应该是return;语句）  
20                 System.out.println("Done finally");  
21             }  
22             return 0;  
23         }  
24     }

 

 输出结果为：

   


总结：

finally其实是仅在return 语句执行前执行，如果return一个函数，那么会先执行函数，但如果函数内有（return）语句，那么finally就会在这个return 语句前执行。finally在catch中的return之前执行但是如果catch中有返回值而finally中也有返回值的话finally中的返回值会替换catch中的返回值，因为catch中的返回值是存放在一个临时区中，try 中的过程和catch 是一样的。

如果catch块有异常向外抛出，执行顺序呢：我执行我，你抛你得异常，我finally我的语句，我俩互不干涉，你别管我啥时执行，但我一定会执行。

关于finally，此时，应该很明朗了只需记着一点：除非调用system.exit()让程序退出也就是将调用这个程序的进程断开了退出了这个程序就不会执行或断电等因素致使程序停止进程终止，否则无论任何因素finally块都一定会执行。

本文转载自 http://blog.csdn.net/qh_java/article/details/12583803  2017-06-0916:48:23 么么哒！！！