異常處理機制

異常處理是對可能出現的異常進行處理，以防止程式遇到異常時被卡死，處於一直等待，或死迴圈。

異常有兩個過程，一個是丟擲異常；一個是捕捉異常。

丟擲異常

丟擲異常有三種形式，一是throw,一個throws，還有一種系統自動拋異常。下面它們之間的異同。

系統自動拋異常

當程式語句出現一些邏輯錯誤、主義錯誤或型別轉換錯誤時，系統會自動丟擲異常。如：

1. publicstaticvoid main(String[] args) {  
2.         int a = 5, b =0;  
3.         System.out.println(5/b);  
4.         //function();
5. }  

Exception in thread "main" java.lang.ArithmeticException: / by zero

at test.ExceptionTest.main(ExceptionTest.java:62)

1. publicstaticvoid main(String[] args) {  
2.         String s = "abc";  
3.         System.out.println(Double.parseDouble(s));  
4.         //function();
5. }  

Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"

at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1224)

at java.lang.Double.parseDouble(Double.java:510)

at test.ExceptionTest.main(ExceptionTest.java:62)

throw

throw是語句丟擲一個異常。
語法：throw (異常物件);
      如：  throw e;

一般會用於程式出現某種邏輯時程式設計師主動丟擲某種特定型別的異常。如：

1. publicstaticvoid main(String[] args) {  
2.         String s = "abc";  
3.         if(s.equals("abc")) {  
4.             thrownew NumberFormatException();  
5.         } else {  
6.             System.out.println(s);  
7.         }  
8.         //function();
9. }  

會丟擲異常：

Exception in thread "main" java.lang.NumberFormatException

at test.ExceptionTest.main(ExceptionTest.java:67)

throws

throws是方法可能丟擲異常的宣告。(用在宣告方法時，表示該方法可能要丟擲異常)
語法：[(修飾符)](返回值型別)(方法名)([引數列表])[throws(異常類)]{......}
      如：      public void function() throws Exception{......}

當某個方法可能會丟擲某種異常時用於throws 宣告可能丟擲的異常，然後交給上層呼叫它的方法程式處理。如：

1. publicstaticvoid function() throws NumberFormatException{  
2.         String s = "abc";  
3.         System.out.println(Double.parseDouble(s));  
4.     }  
5.     publicstaticvoid main(String[] args) {  
6.         try {  
7.             function();  
8.         } catch (NumberFormatException e) {  
9.             System.err.println("非資料型別不能轉換。");  
10.             //e.printStackTrace();
11.         }  
12. }  

非資料型別不能轉換。

throw與throws的比較

1、throws出現在方法函式頭；而throw出現在函式體。

2、throws表示出現異常的一種可能性，並不一定會發生這些異常；throw則是丟擲了異常，執行throw則一定丟擲了某種異常物件。

3、兩者都是消極處理異常的方式（這裡的消極並不是說這種方式不好），只是丟擲或者可能丟擲異常，但是不會由函式去處理異常，真正的處理異常由函式的上層呼叫處理。

好的程式設計習慣：

1.在寫程式時，對可能會出現異常的部分通常要用try{...}catch{...}去捕捉它並對它進行處理；

2.用try{...}catch{...}捕捉了異常之後一定要對在catch{...}中對其進行處理，那怕是最簡單的一句輸出語句，或棧輸出e.printStackTrace();

3.如果是捕捉IO輸入輸出流中的異常，一定要在try{...}catch{...}後加finally{...}把輸入輸出流關閉；

4.如果在函式體內用throw丟擲了某種異常，最好要在函式名中加throws拋異常宣告，然後交給呼叫它的上層函式進行處理。

捕捉異常

先講捕捉異常

1. try{  
2. 　……  
3. }catch(Exception e){  
4. 　……  
5. }finally{  
6. 　……  
7. }  

try{……}中放置可能會發生異常的的語句塊，如可能出現異常的函式，也可以是一般的程式語句；catch(){……}用於抓住異常，(Exception e)中Exception是異常的型別，必須是Exception(Exception是所有異常類的父類)的子類。{}定義當出現異常時的處理方法。finally{……}表示不管異常是否發生，都得進行finally{}中的處理。

在捕捉異常的try{...}語句塊中，如果出現了異常，則該語句(出現異常的語句)後的程式語句都不執行，而是跳到catch{...}語句塊中執行異常的處理。如：

1. publicstaticvoid function1() throws NumberFormatException{  
2.         System.out.println(Double.parseDouble("abc"));  
3.         System.out.println("第二條語句。");  
4.     }  
5.     publicstaticvoid main(String[] args) {  
6.         try {  
7.             function1();  
8.         } catch (Exception e) {  
9.             System.err.println(e.getMessage());  
10.             //e.printStackTrace();
11.         }  
12. }  

For input string: "abc"

System.out.println("第二條語句。");未執行。

如果一個函式沒有用throws進行拋異常，在呼叫該函式的方法也同樣可以捕捉異常。如

1. publicstaticvoid function() {  
2.         String s = "abc";  
3.         System.out.println(Double.parseDouble(s));  
4.     }  
5.     publicstaticvoid main(String[] args) {  
6.         try {  
7.             function();  
8.         } catch (Exception e) {  
9.             System.err.println("非資料型別不能轉換。");  
10.             //e.printStackTrace();
11.         }  
12. }  

非資料型別不能轉換。

說明：某個函式或某段程式塊不管會不會，有沒可能丟擲異常，都可以加try{...}catch{...}去捕捉它。

自定義異常

使用者可以自定義異常，新建一個異常類，讓其繼承Exception類或Exception的某個子類。然後用throw丟擲自己定義的異常類物件。如：

1. publicstaticvoid function() throws ParenthesisMatchingException{  
2.         String s = "((a+b)";  
3.         ParenthesisMatchingException e = new ParenthesisMatchingException("括號匹配異常！");  
4.         if(s.charAt(0)=='(' && s.charAt(1)=='(') {  
5.             throw e;  
6.         }  
7.         System.out.println(s);  
8.     }  
9.     publicstaticvoid main(String[] args) {  
10.         try {  
11.             function();  
12.         } catch (Exception e) {  
13.             System.out.println(e.getMessage());  
14.             //e.printStackTrace();
15.         }  
16. }  

括號匹配異常！