Java异常发生时程序的执行顺序

一些基础知识：

1.try代码段包含可能产生例外的代码；
2.try代码段后跟有一个或多个代码段；
3.每个catch代码段声明其能处理的一种特定的异常并提供处理的方法；
4.当异常发生时，程序会终止当前的流程，根据获取异常的类型去执行相应的catch代码段，有多个符合条件的catch时，只执行第一个；
5.finally段的代码无论是否发生异常都会执行。
6.在一个try语句块中，基类异常的捕获语句不可以写在子类异常捕获语句的上面。

 

看一个例子：

 

[java] view plaincopy

1. /** 
2.  * @author Lansine 
3.  *  
4.  */  
5. public class T1 {  
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.         String s = "1";  
12.         try {  
13.             s = "2";  
14.             System.out.println(s);  
15.             if (s == "2")  
16.                 throw new Exception("h");  
17.         } catch (Exception e) {  
18.             s = "3";  
19.             System.out.println(s);  
20.         } finally {  
21.             s = "4";  
22.             System.out.println(s);  
23.         }  
24.         s = "5";  
25.         System.out.println(s);  
26.   
27.     }  
28.   
29. }  

输出的结果是2,3,4,5    (这里的逗号只用于显示)。上述语句非常清楚，但是在上述结构中加上return，就变得有些复杂了，如  

 

[java] view plaincopy

1. /** 
2.  * @author Lansine 
3.  *  
4.  */  
5. public class T2 {  
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.         String s = "1";  
12.         try {  
13.             s = "2";  
14.             System.out.println(s);  
15.             return;  
16.         } catch (Exception e) {  
17.             s = "3";  
18.             System.out.println(s);  
19.         } finally {  
20.             s = "4";  
21.             System.out.println(s);  
22.         }  
23.         s = "5";  
24.         System.out.println(s);  
25.   
26.     }  
27.   
28. }  

输出的结果是2,4也就是说在try结构中,虽然使用了return语句强制函数返回，不再往下执行，但实现上finally中的还是执行了。但除了finally外的其它语句不再被执行。

一个更流行的例子是：

[java] view plaincopy

1. import java.io.*;  
2.   
3. /** 
4.  * @author Lansine 
5.  *  
6.  */  
7.   
8. public class Mine {  
9.     public static void main(String argv[]){  
10.         Mine m = new Mine();  
11.         try {  
12.             System.out.println(m.amethod());  
13.         } catch (Exception e) {  
14.             // TODO 自动生成 catch 块  
15.             //e.printStackTrace();  
16.             System.out.println("我知道了");  
17.         }  
18.         System.out.println("finished");  
19.     }  
20.   
21.     public int amethod()throws Exception {  
22.         try {  
23.             FileInputStream dis = new FileInputStream("Hello.txt"); // 1，抛出异常  
24.             System.out.println("异常发生之后");  
25.         } catch (Exception ex) {  
26.             System.out.println("No such file found"); // 2.catch捕捉异常，并执行  
27.             //throw new Exception("上面处理");  
28.             return -1; // 4,return 返回  
29.         } finally {  
30.             System.out.println("Doing finally"); // 3.finally一定会执行，在return之前。  
31.         }  
32.   
33.         System.out.println("在代码后面");  
34.   
35.         return 0;  
36.     }  
37. }  

结果是：

[java] view plaincopy

1. No such file found  
2. Doing finally  
3. -1  
4. finished  

如果在catch块中抛出异常，则结果为：

[java] view plaincopy

1. No such file found  
2. Doing finally  
3. 我知道了  
4. finished  

 

注意：如果异常往上抛直到main函数还没有被catch处理的话，程序将被异常终止。