Java&&深入理解異常處理

簡介

異常處理是java語言的重要特性之一，《Three Rules for effective Exception Handling》一文中是這麼解釋的：它主要幫助我們在debug的過程中解決下面的三個問題。

• 什麼出錯了
• 哪裏出錯了
• 爲什麼出錯

   java語言可以說是提供了完善的異常處理機制。java中的異常機制包括Error和Exception兩個部分。他們都繼承自一個共同的基類Throwable。

Error：屬於JVM運行中發生的一些錯誤，雖然並不屬於開發人員的範疇，而是代碼運行時JVM出現的問題，但是有些Error還是由代碼引起的。比如StackOverflowError經常由遞歸操作引起，這種錯誤就是告訴開發者，你一般無法挽救，只能靠JVM，例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。這些錯誤表示故障發生於虛擬機自身、或者發生在虛擬機試圖執行應用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因爲它們在應用程序的控制和處理能力之外，而且絕大多數是程序運行時不允許出現的狀況。對於設計合理的應用程序來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。

Exception：是程序本身可以處理的異常。(注意：異常和錯誤的區別：異常能被程序本身可以處理，錯誤是無法處理)假設程序員會去處理這些異常，比如數據庫連接出了異常，那麼我們可以處理這個異常，並且重新連接等。Exception分爲兩種，檢查類型（checked）和未檢查類型（unchecked）。檢查類型的異常就是說要程序員明確的去聲明(throws)或者用try..catch語句來處理的異常，否則編譯不會通過。  除了RuntimeException及其子類以外，其他的Exception類及其子類都屬於可查異常。而非檢查類型的異常則沒有這些限制，比如我們常見的 NullPointerException 就是非檢查類型的，他繼承自RuntimeException。java是目前主流編程語言中唯一一個推崇使用檢查類型異常的，至少sun是這樣的。關於使用checked還是unchecked異常的論戰一直很激烈。

綜上：

 Exception 這種異常分兩大類運行時異常和非運行時異常(編譯異常)。程序中應當儘可能去處理這些異常。

       運行時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應該從邏輯角度儘可能避免這類異常的發生。

      運行時異常的特點是Java編譯器不會檢查它，也就是說，當程序中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。
       非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬於Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。

下面是一張java語言中異常的類關係圖。

處理機制

        在 Java 應用程序中，異常處理機制爲：拋出異常，捕捉異常。

        拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象並交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼並執行。

        捕獲異常：在方法拋出異常之後，運行時系統將轉爲尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即爲合適 的異常處理器。運行時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合適異常處理器的方法並執行。當運行時系統遍歷調用棧而未找到合適 的異常處理器，則運行時系統終止。同時，意味着Java程序的終止。

        對於運行時異常、錯誤或可查異常，Java技術所要求的異常處理方式有所不同。

        由於運行時異常的不可查性，爲了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程序忽略運行時異常。

       對於方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因爲，大多數Error異常屬於永遠不能被允許發生的狀況，也屬於合理的應用程序不該捕捉的異常。

       對於所有的可查異常，Java規定：一個方法必須捕捉，或者聲明拋出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常。

        能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由於自身語句所引發並拋出的異常，也可能是由某個調用的方法或者Java運行時 系統等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所拋出的異常。簡單地說，異常總是先被拋出，後被捕捉的。

         任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。

        從方法中拋出的任何異常都必須使用throws子句。

        捕捉異常通過try-catch語句或者try-catch-finally語句實現。

         總體來說，Java規定：對於可查異常必須捕捉、或者聲明拋出。允許忽略不可查的RuntimeException和Error。

基本使用

1.try-catch語句

    我們在使用java的一些文件或者數據庫操作的時候已經接觸過一些異常了，比如IOException、SQLException等，這些方法被聲明可能會拋出某種異常，因此我們需要對其進行捕獲處理。這就需要基本的try..catch語句了。下圖就是我們經常寫的一個基本結構。try語句塊中寫可能會拋出異常的代碼，之後在catch語句塊中進行捕獲。我們看到catch的參數寫的是一個Exception對象，這就意味着這個語句塊可以捕獲所有的檢查類型的異常（雖然這並不是一種好的寫法，稍後討論），finally總是會保證在最後執行，一般我們在裏面處理一些清理的工作，比如關閉文件流或者數據庫、網絡等操作。

當然上面的語句塊結構是靈活的，但是try是必須有的，catch和finally兩者至少有一個，當然catch的數量可以有多個。有時候try語句塊中可能拋出多種類型的異常，這個時候，我們可以寫多個catch語句來捕獲不同類型的異常，一個比較好的寫法如下：

try{
            // ..invoke some methods that may throw exceptions
        }catch(ExceptionType1 e){
            //...handle exception
        }catch(ExceptionType2 e){
            //...handle exception
        }catch(Exception e){
            //...handle exception
        }finally{
            //..do some cleaning :close the file db etc.
        }

  初次學習try..catch總會被其吸引，所以大量的使用這種結果，以達到某種“魯棒性”。（這語句也是程序員表白的最愛）。但try語句實際上執行的時候會導致棧操作。即要保存整個方法的調用路徑，這勢必會使得程序變慢。fillInStackTrace()是Throwable的一個方法，用來執行棧的操作，他是線程同步的，本身也很耗時。這裏問題在StackOverFlow上曾經有過一段非常經典的討論，原文。 的確當我們在try中什麼都不做，或者只執行一個類似加法的簡單調用，那麼其執行效率和goto這樣的控制語句是幾乎一樣的。但是誰會寫這樣的代碼呢？

    總之不要總是試圖通過try catch來控制程序的結構，無論從效率還是代碼的可讀性上都不好。

try catch好的一面

    try catch雖然不推薦用於程序結構的控制，但是也具有重要的意義，其設計的一個好處就是，開發人員可以把一件事情當做事務來處理，事務也是數據庫中重要的概念，舉個例子，比如完成訂單的這個事務，其中包括了一個動作序列，包括用戶提交訂單，商品出庫，關聯等。當這個序列中某一個動作執行失敗的時候，數據統一恢復到一個正常的點，這樣就不會出現，你付完了帳，商品卻沒有給你的情況。我們在try語句塊中就像執行一個事務一樣，當出現了異常，就會在catch中得到統一的處理，保證數據的完整無損。其實很多不好的代碼也是因爲沒有好好利用catch語句的語言，導致很多異常就被淹沒了，這個後面介紹。

舉例

例1  捕捉throw語句拋出的“除數爲0”異常。

<span style="font-size:12px;">public class TestException {  
    public static void main(String[] args) {  
        int a = 6;  
        int b = 0;  
        try { // try監控區域  
              
            if (b == 0) throw new ArithmeticException(); // 通過throw語句拋出異常  
            System.out.println("a/b的值是：" + a / b);  
        }  
        catch (ArithmeticException e) { // catch捕捉異常  
            System.out.println("程序出現異常，變量b不能爲0。");  
        }  
        System.out.println("程序正常結束。");  
    }  
}  </span>

運行結果：程序出現異常，變量b不能爲0。

                    程序正常結束。

        例1  在try監控區域通過if語句進行判斷，當“除數爲0”的錯誤條件成立時引發ArithmeticException異常，創建 ArithmeticException異常對象，並由throw語句將異常拋給Java運行時系統，由系統尋找匹配的異常處理器catch並運行相應異 常處理代碼，打印輸出“程序出現異常，變量b不能爲0。”try-catch語句結束，繼續程序流程。

        事實上，“除數爲0”等ArithmeticException，是RuntimException的子類。而運行時異常將由運行時系統自動拋出，不需要使用throw語句。

例2  捕捉運行時系統自動拋出“除數爲0”引發的ArithmeticException異常。

<span style="font-size:12px;">public static void main(String[] args) {  
        int a = 6;  
        int b = 0;  
        try {  
            System.out.println("a/b的值是：" + a / b);  
        } catch (ArithmeticException e) {  
            System.out.println("程序出現異常，變量b不能爲0。");  
        }  
        System.out.println("程序正常結束。");  
    }  
}  </span>

運行結果：程序出現異常，變量b不能爲0。

                  程序正常結束。

例2  中的語句：

System.out.println("a/b的值是：" + a/b);

      在運行中出現“除數爲0”錯誤，引發ArithmeticException異常。運行時系統創建異常對象並拋出監控區域，轉而匹配合適的異常處理器catch，並執行相應的異常處理代碼。

      由於檢查運行時異常的代價遠大於捕捉異常所帶來的益處，運行時異常不可查。Java編譯器允許忽略運行時異常，一個方法可以既不捕捉，也不聲明拋出運行時異常。

例3  不捕捉、也不聲明拋出運行時異常。

public class TestException {  
    public static void main(String[] args) {  
        int a, b;  
        a = 6;  
        b = 0; // 除數b 的值爲0  
        System.out.println(a / b);  
    }  
}  

運行結果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.TestException.main(TestException.java:8)

例4  程序可能存在除數爲0異常和數組下標越界異常。

public class TestException {  
    public static void main(String[] args) {  
        int[] intArray = new int[3];  
        try {  
            for (int i = 0; i <= intArray.length; i++) {  
                intArray[i] = i;  
                System.out.println("intArray[" + i + "] = " + intArray[i]);  
                System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值:  "  
                        + intArray[i] % (i - 2));  
            }  
        } catch (ArrayIndexOutOfBoundsException e) {  
            System.out.println("intArray數組下標越界異常。");  
        } catch (ArithmeticException e) {  
            System.out.println("除數爲0異常。");  
        }  
        System.out.println("程序正常結束。");  
    }  
}  運行結果：
intArray[0] = 0
intArray[0]模 -2的值:  0
intArray[1] = 1
intArray[1]模 -1的值:  0
intArray[2] = 2
除數爲0異常。
程序正常結束。
      例4  程序可能會出現除數爲0異常，還可能會出現數組下標越界異常。程序運行過程中ArithmeticException異常類型是先行匹配的，因此執行相匹配的catch語句：
catch (ArithmeticException e){
      System.out.println("除數爲0異常。");
 }

       需要注意的是，一旦某個catch捕獲到匹配的異常類型，將進入異常處理代碼。一經處理結束，就意味着整個try-catch語句結束。其他的catch子句不再有匹配和捕獲異常類型的機會。
      Java通過異常類描述異常類型，異常類的層次結構如圖1所示。對於有多個catch子句的異常程序而言，應該儘量將捕獲底層異常類的catch子 句放在前面，同時儘量將捕獲相對高層的異常類的catch子句放在後面。否則，捕獲底層異常類的catch子句將可能會被屏蔽。
      RuntimeException異常類包括運行時各種常見的異常，ArithmeticException類和ArrayIndexOutOfBoundsException類都是它的子類。因此，RuntimeException異常類的catch子句應該放在 最後面，否則可能會屏蔽其後的特定異常處理或引起編譯錯誤。

2. try－catch-finally語句

 try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現異常，都應當執行的內容，般我們在裏面處理一些清理的工作，比如關閉文件流或者數據庫、網絡等操作。try-catch-finally語句的一般語法形式爲：

              try {
    // 可能會發生異常的程序代碼
} catch (Type1 id1) {
    // 捕獲並處理try拋出的異常類型Type1
} catch (Type2 id2) {
    // 捕獲並處理try拋出的異常類型Type2
} finally {
    // 無論是否發生異常，都將執行的語句塊
}

例5  帶finally子句的異常處理程序。

public class TestException {
    public static void main(String args[]) {
        int i = 0;
        String greetings[] = { " Hello world !", " Hello World !! ",
                " HELLO WORLD !!!" };
        while (i < 4) {
            try {
                // 特別注意循環控制變量i的設計，避免造成無限循環
                System.out.println(greetings[i++]);
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("數組下標越界異常");
            } finally {
                System.out.println("--------------------------");
            }
        }
    }
}

運行結果：

Hello world !

--------------------------

Hello World !!

--------------------------

HELLO WORLD !!!

--------------------------

數組下標越界異常

--------------------------

     在例5中，請特別注意try子句中語句塊的設計，如果設計爲如下，將會出現死循環。如果設計爲：

try {
      System.out.println (greetings[i]); i++;
}

小結：

try 塊：用於捕獲異常。其後可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。
catch 塊：用於處理try捕獲到的異常。
finally 塊：無論是否捕獲或處理異常，finally塊裏的語句都會被執行。當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執行。在以下4種特殊情況下，finally塊不會被執行：
1）在finally語句塊中發生了異常。
2）在前面的代碼中用了System.exit()退出程序。
3）程序所在的線程死亡。
4）關閉CPU。

3. try-catch-finally 規則(異常處理語句的語法規則）：

1)  必須在 try 之後添加 catch 或 finally 塊。try 塊後可同時接 catch 和 finally 塊，但至少有一個塊。
2) 必須遵循塊順序：若代碼同時使用 catch 和 finally 塊，則必須將 catch 塊放在 try 塊之後。
3) catch 塊與相應的異常類的類型相關。
4) 一個 try 塊可能有多個 catch 塊。若如此，則執行第一個匹配塊。即Java虛擬機會把實際拋出的異常對象依次和各個catch代碼塊聲明的異常類型匹配，如果異常對象爲某個異常類型或其子類的實例，就執行這個catch代碼塊，不會再執行其他的 catch代碼塊
5) 可嵌套 try-catch-finally 結構。
6) 在 try-catch-finally 結構中，可重新拋出異常。
7) 除了下列情況，總將執行 finally 做爲結束：JVM 過早終止（調用 System.exit(int)）；在 finally 塊中拋出一個未處理的異常；計算機斷電、失火、或遭遇病毒攻擊。

try、catch、finally語句塊的執行順序:

1)當try沒有捕獲到異常時：try語句塊中的語句逐一被執行，程序將跳過catch語句塊，執行finally語句塊和其後的語句；

2)當try捕獲到異常，catch語句塊裏沒有處理此異常的情況：當try語句塊裏的某條語句出現異常時，而沒有處理此異常的catch語句塊時，此異常將會拋給JVM處理，finally語句塊裏的語句還是會被執行，但finally語句塊後的語句不會被執行；

3)當try捕獲到異常，catch語句塊裏有處理此異常的情況：在try語句塊中是按照順序來執行的，當執行到某一條語句出現異常時，程序將跳到catch語句塊，並與catch語句塊逐一匹配，找到與之對應的處理程序，其他的catch語句塊將不會被執行，而try語句塊中，出現異常之後的語句也不會被執行，catch語句塊執行完後，執行finally語句塊裏的語句，最後執行finally語句塊後的語句。

如下圖所示：

                                               

圖2  圖示try、catch、finally語句塊的執行

拋出異常

      任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。從方法中拋出的任何異常都必須使用throws子句。

1. throws拋出異常

   如果一個方法可能會出現異常，但沒有能力處理這種異常，可以在方法聲明處用throws子句來聲明拋出異常。例如汽車在運行時可能會出現故障，汽車本身沒辦法處理這個故障，那就讓開車的人來處理。

使用throws關鍵字將異常拋給調用者後，如果調用者不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的調用者。

    pop方法沒有處理異常NegativeArraySizeException，而是由main函數來處理。

     throws語句用在方法定義時聲明該方法要拋出的異常類型，如果拋出的是Exception異常類型，則該方法被聲明爲拋出所有的異常。多個異常可使用逗號分割。throws語句的語法格式爲：

methodname throws Exception1,Exception2,..,ExceptionN{}  

  方法名後的throws Exception1,Exception2,...,ExceptionN 爲聲明要拋出的異常列表。當方法拋出異常列表的異常時，方法將不對這些類型及其子類類型的異常作處理，而拋向調用該方法的方法，由他去處理。例如：
import java.lang.Exception;  
public class TestException {  
    static void pop() throws NegativeArraySizeException {  
        // 定義方法並拋出NegativeArraySizeException異常  
        int[] arr = new int[-3]; // 創建數組  
    }  
  
    public static void main(String[] args) { // 主方法  
        try { // try語句處理異常信息  
            pop(); // 調用pop()方法  
        } catch (NegativeArraySizeException e) {  
            System.out.println("pop()方法拋出的異常");// 輸出異常信息  
        }  
    }  
  
}  

使用throws關鍵字將異常拋給調用者後，如果調用者不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的調用者。pop方法沒有處理異常NegativeArraySizeException，而是由main函數來處理。
Throws拋出異常的規則：
    1) 如果是不可查異常（unchecked exception），即Error、RuntimeException或它們的子類，那麼可以不使用throws關鍵字來聲明要拋出的異常，編譯仍能順利通過，但在運行時會被系統拋出。
    2）必須聲明方法可拋出的任何可查異常（checked exception）。即如果一個方法可能出現受可查異常，要麼用try-catch語句捕獲，要麼用throws子句聲明將它拋出，否則會導致編譯錯誤
   3)僅當拋出了異常，該方法的調用者才必須處理或者重新拋出該異常。當方法的調用者無力處理該異常的時候，應該繼續拋出，而不是囫圇吞棗。
          4）調用方法必須遵循任何可查異常的處理和聲明規則。若覆蓋一個方法，則不能聲明與覆蓋方法不同的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類。

例如：

void method1() throws IOException{}  //合法    
   
//編譯錯誤，必須捕獲或聲明拋出IOException    
void method2(){    
  method1();    
}    
   
//合法，聲明拋出IOException    
void method3()throws IOException {    
  method1();    
}    
   
//合法，聲明拋出Exception，IOException是Exception的子類    
void method4()throws Exception {    
  method1();    
}    
   
//合法，捕獲IOException    
void method5(){    
 try{    
    method1();    
 }catch(IOException e){…}    
}    
   
//編譯錯誤，必須捕獲或聲明拋出Exception    
void method6(){    
  try{    
    method1();    
  }catch(IOException e){throw new Exception();}    
}    
   
//合法，聲明拋出Exception    
void method7()throws Exception{    
 try{    
  method1();    
 }catch(IOException e){throw new Exception();}    
}   

判斷一個方法可能會出現異常的依據如下：
     1）方法中有throw語句。例如，以上method7()方法的catch代碼塊有throw語句。
     2）調用了其他方法，其他方法用throws子句聲明拋出某種異常。例如，method3()方法調用了method1()方法，method1()方法聲明拋出IOException，因此，在method3()方法中可能會出現IOException。

2. 使用throw拋出異常

　  throw總是出現在函數體中，用來拋出一個Throwable類型的異常。程序會在throw語句後立即終止，它後面的語句執行不到，然後在包含它的所有try塊中（可能在上層調用函數中）從裏向外尋找含有與其匹配的catch子句的try塊。
　　我們知道，異常是異常類的實例對象，我們可以創建異常類的實例對象通過throw語句拋出。該語句的語法格式爲：
    throw new exceptionname();
    例如拋出一個IOException類的異常對象：
    throw new IOException();
    要注意的是，throw 拋出的只能夠是可拋出類Throwable 或者其子類的實例對象。下面的操作是錯誤的：
    throw new String("exception");

    這是因爲String 不是Throwable 類的子類。

     如果拋出了檢查異常，則還應該在方法頭部聲明方法可能拋出的異常類型。該方法的調用者也必須檢查處理拋出的異常。

       如果所有方法都層層上拋獲取的異常，最終JVM會進行處理，處理也很簡單，就是打印異常消息和堆棧信息。如果拋出的是Error或RuntimeException，則該方法的調用者可選擇處理該異常。

<span style="font-size:12px;">package Test;  
import java.lang.Exception;  
public class TestException {  
    static int quotient(int x, int y) throws MyException { // 定義方法拋出異常  
        if (y < 0) { // 判斷參數是否小於0  
            throw new MyException("除數不能是負數"); // 異常信息  
        }  
        return x/y; // 返回值  
    }  
    public static void main(String args[]) { // 主方法  
        int  a =3;  
        int  b =0;   
        try { // try語句包含可能發生異常的語句  
            int result = quotient(a, b); // 調用方法quotient()  
        } catch (MyException e) { // 處理自定義異常  
            System.out.println(e.getMessage()); // 輸出異常信息  
        } catch (ArithmeticException e) { // 處理ArithmeticException異常  
            System.out.println("除數不能爲0"); // 輸出提示信息  
        } catch (Exception e) { // 處理其他異常  
            System.out.println("程序發生了其他的異常"); // 輸出提示信息  
        }  
    }  
  
}  
class MyException extends Exception { // 創建自定義異常類  
    String message; // 定義String類型變量  
    public MyException(String ErrorMessagr) { // 父類方法  
        message = ErrorMessagr;  
    }  
  
    public String getMessage() { // 覆蓋getMessage()方法  
        return message;  
    }  
}  </span>

異常鏈

      1) 如果調用quotient(3,-1)，將發生MyException異常，程序調轉到catch (MyException e)代碼塊中執行；

      2) 如果調用quotient(5,0)，將會因“除數爲0”錯誤引發ArithmeticException異常，屬於運行時異常類，由Java運行時系統自動拋出。quotient（）方法沒有捕捉ArithmeticException異常，Java運行時系統將沿方法調用棧查到main方法，將拋出的異常上傳至quotient（）方法的調用者：

         int result = quotient(a, b); // 調用方法quotient()
        由於該語句在try監控區域內，因此傳回的“除數爲0”的ArithmeticException異常由Java運行時系統拋出，並匹配catch子句：

       catch (ArithmeticException e) { // 處理ArithmeticException異常
System.out.println("除數不能爲0"); // 輸出提示信息
} 

        處理結果是輸出“除數不能爲0”。Java這種向上傳遞異常信息的處理機制，形成異常鏈。

       Java方法拋出的可查異常將依據調用棧、沿着方法調用的層次結構一直傳遞到具備處理能力的調用方法，最高層次到main方法爲止。如果異常傳遞到main方法，而main不具備處理能力，也沒有通過throws聲明拋出該異常，將可能出現編譯錯誤。

      3)如還有其他異常發生，將使用catch (Exception e)捕捉異常。由於Exception是所有異常類的父類，如果將catch (Exception e)代碼塊放在其他兩個代碼塊的前面，後面的代碼塊將永遠得不到執行，就沒有什麼意義了，所以catch語句的順序不可掉換。

Throwable類中的常用方法

注意：catch關鍵字後面括號中的Exception類型的參數e。Exception就是try代碼塊傳遞給catch代碼塊的變量類型，e就是變量名。catch代碼塊中語句"e.getMessage();"用於輸出錯誤性質。通常異常處理常用3個函數來獲取異常的有關信息:

     getCause()：返回拋出異常的原因。如果 cause 不存在或未知，則返回 null。

　 getMeage()：返回異常的消息信息。

　 printStackTrace()：對象的堆棧跟蹤輸出至錯誤輸出流，作爲字段 System.err 的值。

     有時爲了簡單會忽略掉catch語句後的代碼，這樣try-catch語句就成了一種擺設，一旦程序在運行過程中出現了異常，就會忽略處理異常，而錯誤發生的原因很難查找。

JAVA常見異常

  

在Java中提供了一些異常用來描述經常發生的錯誤，對於這些異常，有的需要程序員進行捕獲處理或聲明拋出，有的是由Java虛擬機自動進行捕獲處理。Java中常見的異常類:

1. runtimeException子類:

    1、 java.lang.ArrayIndexOutOfBoundsException
    數組索引越界異常。當對數組的索引值爲負數或大於等於數組大小時拋出。
    2、java.lang.ArithmeticException
    算術條件異常。譬如：整數除零等。
    3、java.lang.NullPointerException
    空指針異常。當應用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等
    4、java.lang.ClassNotFoundException
    找不到類異常。當應用試圖根據字符串形式的類名構造類，而在遍歷CLASSPAH之後找不到對應名稱的class文件時，拋出該異常。

   5、java.lang.NegativeArraySizeException  數組長度爲負異常

   6、java.lang.ArrayStoreException 數組中包含不兼容的值拋出的異常

   7、java.lang.SecurityException 安全性異常

   8、java.lang.IllegalArgumentException 非法參數異常

2.IOException

IOException：操作輸入流和輸出流時可能出現的異常。

EOFException   文件已結束異常

FileNotFoundException   文件未找到異常

3. 其他

ClassCastException    類型轉換異常類

ArrayStoreException  數組中包含不兼容的值拋出的異常

SQLException   操作數據庫異常類

NoSuchFieldException   字段未找到異常

NoSuchMethodException   方法未找到拋出的異常

NumberFormatException    字符串轉換爲數字拋出的異常

StringIndexOutOfBoundsException 字符串索引超出範圍拋出的異常

IllegalAccessException  不允許訪問某類異常

InstantiationException  當應用程序試圖使用Class類中的newInstance()方法創建一個類的實例，而指定的類對象無法被實例化時，拋出該異常

自定義異常

我們可以自己定義異常，以捕獲處理某個具體的例子。創建自己的異常類，可以直接繼承Exception或者RuntimeException。區別是前者是簡稱類型的，而後者爲檢查類型異常。Sun官方力挺傳統的觀點，他建議開發者都是用檢查類型的異常，即你一定要去處理的異常。下面是定義的一個簡單的異常類.

public class SimpleException extends Exception{

    SimpleException(){}
    SimpleException(String info){
        super(info);
    }
}

我們覆寫了兩個構造方法，這是有意義的。通過傳遞字符串參數，我們創建一個異常對象的時候，可以記錄下詳細的信息，這樣這個異常被捕獲的時候就會顯示我們之前定義的詳細信息。比如用下面的代碼測試一下我們定義的異常類：

<span style="font-weight: normal;"><span style="font-size:12px;">public class Test {

    public void fun() throws SimpleException{
        throw new SimpleException("throwing from fun");
    }
    public static void main(String[] args) {
        Test t = new Test();
        try{
            t.fun();
        }catch(SimpleException e){
            e.printStackTrace();
        }
    }
}</span></span>

運行就會得到下面的結果 printStackTrace是打印調用棧的方法，他有三個重載方法，默認的是將信息輸出到System.err。這樣我們就可以清晰的看到方法調用的過程，有點像操作系統中的中斷，保護現場。

SimpleException: throwing from fun
at Test.fun(Test.java:4)
at Test.main(Test.java:9)

略微麻煩的語法

   我們自己實現的異常有時候會用到繼承這些特性，在異常繼承的時候有一些限制。那就是子類不能拋出基類或所實現的接口中沒有拋出的異常.

 關於checked和unchecked的論戰

  傳統的觀點裏，sun認爲"因爲 Java 語言並不要求方法捕獲或者指定運行時異常，因此編寫只拋出運行時異常的代碼或者使得他們的所有異常子類都繼承自 RuntimeException ，對於程序員來說是有吸引力的。這些編程捷徑都允許程序員編寫 Java 代碼而不會受到來自編譯器的所有挑剔性錯誤的干擾，並且不用去指定或者捕獲任何異常。 儘管對於程序員來說這似乎比較方便，但是它迴避了 Java 的捕獲或者指定要求的意圖，並且對於那些使用您提供的類的程序員可能會導致問題。"他強調儘量不使用unchecked異常。

  但《Thinking in java》的作者Eckel卻改變了自己的想法， 他在自己博客上的一篇文章（這篇文章很好，表達也很簡單）專門列舉了使用checked異常的弊端。他指出正式檢查類型讓導致了很多的異常不能被程序員發現。開發人員有更大的自由去決定是不是要處理一個異常。即使忘記處理了某個異常，他也會在某個地方拋出來被發現，而不至於丟失。checked異常使得代碼的可讀性變差，並且正在暗暗的鼓勵人們去淹沒異常。現在很多IDE都在提醒我們，某個方法要跑出異常，然後甚至自動幫我們生成catch或者throw。這是非常可怕的行爲，這導致了我們很多catch語句裏面什麼都沒有，就像一個陷阱一樣。

  checked異常帶來的另一個問題是，代碼的難維護性，因爲要在方法聲明上加上throws，如果方法的實現發生了某個變化，有了新的異常，那麼我們不得不去修改方法的聲明。還有一點不好的就是不能明確的暴露異常的特徵。比如我們登錄成績系統的時候，如果用戶名註冊，我們可能期待一個NoSuchStudentException但是實際看到的可能是一個SQLException。《Effective java》中第 43 條：拋出與抽象相適應的異常。講的就是這個原則，即拋出的異常應該是和抽象的概念一致的，比如我們在一個系統無論遇到什麼具體的問題，但是大部分我們看到的都只是SQLException而已。

  關於如何選擇，Bloch的建議是爲可恢復的條件使用檢查型異常，爲編程錯誤使用運行時異常。我的感覺是選擇檢查的異常就一定要”處理“,當然此處的處理一定是真正的處理而不是空寫一個catch語句而已。不知道未來的java會怎樣對待checked和unchecked，畢竟現在java是唯一一個支持檢查異常的主流編程語言了。

好的原則

      Fail Fast:就是要儘早的拋出異常，這樣有有助於更加精確的定位出錯的地點和原因。這個也比較好理解，比如用戶名字不合法的時候馬上拋出，UserNameIllegalException，如果沒有及時拋出異常，那麼不合法的名字可能會導致一個SQLException,但是程序報給你一個SQLException,你卻很難直接得知一定是用戶名不合法造成的。Fail Fast這種思想，在java實現ArrayList的機制中也有很好的體現。

     Catch late:不要在方法內部過早的處理異常，特別是什麼也不做的處理，那就更加的可怕了。因爲如果“無作爲”的處理很可能導致後面繼續出現新的異常（比如錯誤的用戶名會引發後面一些列錯誤，程序還不能處理好錯誤的用戶名，後面的就更處理不了了），這就給調試增加了很大的困難。一個好的經驗是將異常處理交給調用者，方法只在及時的地方拋出異常，技術上實現的方式就是給方法聲明throws，標出所有可能要拋出的異常。

     Doc：文檔的重要性，特別是非檢查的異常，一定要在文檔中註明。