java中的try,catch,finally用法

本文出处：http://blog.csdn.net/hwwn2009/article/details/44976025

Java中try,catch,finally的用法，以前感觉还算熟悉，但看到一篇博文才有更深点的理解，总结网友博客如下。

Java异常处理的组合方式：

1.try+catch 
运行流程：运行到try块中，如果有异常抛出，则转到catch块去处理。然后执行catch块后面的语句 

2.try+catch+finally 

运行流程：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，再执行finally块后面的代码。

如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后面的语句 

3.try+finally 
运行流程：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗？不会！因为你没有处理异常，所以遇到异常后，执行完finally后，方法就以抛出异常的方式退出。 
这种方式中要注意的是，由于你没有捕获异常，所以要在方法后面声明抛出异常。

共同点：
1.在catch块和finally块中仍然可以再抛出新的异常
例如 throw new Exception("illegal invoked");
如果对于新抛出的异常没有写try的话，则要在方法后面声明抛出异常

反之，如果给catch块或finally块里的异常再套上一层try,catch的话，方法后面就不必声明异常了。

问题：try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后? 

我们来看下面代码：

[java]  view plain  copy

1. public  class Test {  
2.   
3.     /** 
4.      * @param args add by zxx ,Dec 9, 2008 
5.      */  
6.     public static void main(String[] args) {  
7.         // TODO Auto-generated method stub  
8.         System.out.println(new Test().test());;  
9.     }  
10.   
11.     static int test()  
12.     {  
13.         int x = 1;  
14.         try  
15.         {  
16.             return x;  
17.         }  
18.         finally  
19.         {  
20.             ++x;  
21.         }  
22.     }  
23.       
24. }  

---------执行结果 ---------
1

[java]  view plain  copy

1. public class  smallT  
2. {  
3.     public static void  main(String args[])  
4.     {  
5.         smallT t  = new  smallT();  
6.         int  b  =  t.get();  
7.         System.out.println(b);  
8.     }  
9.       
10.     public int  get()  
11.     {  
12.         try  
13.         {  
14.             return 1 ;  
15.         }  
16.         finally  
17.         {  
18.             return 2 ;  
19.         }  
20.     }  
21. }  

---------执行结果 ---------
2

[java]  view plain  copy

1. public  class Test {  
2.   
3.     /** 
4.      * @param args add by zxx ,Dec 9, 2008 
5.      */  
6.     public static void main(String[] args) {  
7.         // TODO Auto-generated method stub  
8.         System.out.println(new Test().test());;  
9.     }  
10.   
11.     int test()  
12.     {  
13.         try  
14.         {  
15.             return func1();  
16.         }  
17.         finally  
18.         {  
19.             return func2();  
20.         }  
21.     }  
22.       
23.     int func1()  
24.     {  
25.         System.out.println("func1");  
26.         return 1;  
27.     }  
28.     int func2()  
29.     {  
30.         System.out.println("func2");  
31.         return 2;  
32.     }     
33. }  

-----------执行结果-----------------
func1
func2
2

分析：

从上面3个例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。