摘要：所有能夠處理該異常的方法，都來自一個叫做調用堆棧的方法列表。如果運行環境在調用堆棧中自始至終未能找到捕獲這個異常的代碼塊，那么整個程序將終止運行。

本文嘗試以盡可能詳細的方式介紹 Java 當中的異常概念和處理機制。本文適合 Java 初學者閱讀。

異常是發生在程序運行過程中的，阻斷正常流程中的指令執行的事件。

當一個方法在執行當中發生錯誤時，這個方法就會創建一個特別的對象，將其交付給 Java 運行環境處理。這個對象被稱作“異常對象”（或簡稱異常），它當中包含了異常事件的類型和狀態等等信息。 創建這個對象并將其交付給 Java 運行環境的過程，稱作“拋出異常”。

  
異常對象：

  所有的異常對象都繼承于 java.lang.Exception 類。不同類型的異常被定義成它的不同子類。常見的異常類型有 java.io.IOException（讀寫異常），java.lang.NullPointerException（空指針異常）等。

當一個方法拋出異常（或“異常對象”）時，運行環境就會嘗試尋找某個方法去處理它。所有能夠處理該異常的方法，都來自一個叫做“調用堆棧”的方法列表。這個列表的最頂層就是拋出該異常的方法，往下是調用該方法的方法，然后依次類推。

例如a()方法當中調用了b()方法，b()方法當中調用了c()方法，那么當c()方法拋出異常時，它就在調用堆棧的最頂層，往下是b()方法，再往下就是a()方法。

運行環境會沿著調用堆棧往下尋找，尋找方法當中是否存在能夠處理這個異常的代碼塊。這樣的代碼塊叫做“捕獲異常”。運行環境將異常對象交給這個“捕獲異常”的代碼塊處理。如果運行環境在調用堆棧中自始至終未能找到捕獲這個異常的代碼塊，那么整個程序將終止運行。

當你編寫一個方法 a()，當中調用了方法 b()，而該方法可能拋出異常，那么你有兩種選擇：

一、在 a() 方法中用 try-catch 結構捕獲 b() 方法拋出的異常，方式如下：

// 示例1
try {
    ...
    b();
    ...
} catch (Exception e) {
    // 處理異常對象
}

二、在 a() 方法上聲明為拋出 b() 方法所拋出的異常，像這樣：

// 示例2
public void a() throws Exception {
    ...
    b();
    ...
}

這樣的話，調用 a() 方法的那個方法，同樣面臨兩種選擇：捕獲，或繼續拋出。如果你不在這兩種處理方式當中選擇一種，那么編譯器就會判定你的代碼存在錯誤，并拒絕編譯。

開始的時候說過，異常事件會阻斷指令的執行。也就是說，執行到 b() 方法的時候，如果它拋出了異常，那么它后面的指令都不會執行了。比如在第一種情況下（示例 1）拋出異常，那么從 b(); 到 } catch (Exception e) { 之間的所有語句都不會執行；在第二種情況下（示例 2）則是從 b(); 到 a() 方法結束之間的所有語句都不會執行。

接下來我們分別介紹這兩種處理方式。

在 Java 中，捕獲異常的方式是編寫 try-catch-finally 代碼塊。下面是一個例子，讀取指定文件并將文件內容輸出到控制臺：

// 示例3
public static void main(String[] args) {
    java.io.File file = new File("C:1.txt");
    java.io.BufferedReader reader = null;
    String line;

    try {
        reader = new BufferedReader(
                new java.io.FileReader(file));          // 1

        while ((line = reader.readLine()) != null) {    // 2
            System.out.println(line);
        }

    } catch (IOException e) {                           // 3
        e.printStackTrace();

    } finally {                                         // 4
        if (reader != null) {
            try {
                reader.close();                         // 5
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

上面的例子中，1 處的 new FileReader(file) 和 [2] 處的 readLine() 方法都可能拋出 java.io.IOException，所以我們用 try {...} 將它們包起來，表示這部分代碼執行的時候可能拋出異常。

[3] 處為 catch 塊，這部分決定了當異常真的發生時，該如何處理。假如 1 處拋出了異常，那么 Java 運行環境將跳過 try 塊后面的 while 部分，直接轉到 catch 塊來處理這個異常。

catch 后面的 (IOException e) 聲明了被捕獲的異常對象，你可以在 catch 塊中使用它。在這里我們簡單的調用 e.printStackTrace() 方法，將異常信息輸出到控制臺。

注意，try 塊中拋出的異常類型必須與 catch 塊聲明所要捕獲的異常類型匹配，否則編譯器將拒絕編譯。關于這一點的詳情將在后面說明。

[4] 處為 finally 塊，這部分決定了當 try 塊和/或 catch 塊執行完畢后，還要執行哪些代碼，這部分可以看作是“總是會執行的”、“善后工作”。在這里我們嘗試關閉 reader 對象，不論是否出現異常。

注意 reader.close(); 方法也可能拋出異常，所以 [5] 這里又需要用 try-catch-finally 塊包起來。你當然已經注意到，這里沒有 finally 部分。其實 try-catch-finally 塊有三種寫法，分別是：

1. try {...A...} catch(Exception e) {...B...} finally {...C...}
2. try {...A...} catch(Exception e) {...B...}
3. try {...A...} finally {...C...}

寫法 1 的意思是：嘗試 A；如果出現異常則執行 B；不管是否出現異常，都執行 C。
寫法 2 的意思是：嘗試 A；如果出現異常則執行 B。
寫法 3 的意思是：嘗試 A；如果出現異常則不理會拋出去；不管是否出現異常，都執行 C。

在寫法 3 中，如果 try 部分拋出了異常，則需要在當前方法中聲明。聲明拋出異常的方式，將在接下來說明。

任何一個方法都可以通過 throws 關鍵字聲明自己可能拋出異常。下面是一個例子：

// 示例4
public void f() throws Exception {
    ...
}

在這個例子中，方法 f() 聲明自己可能會拋出 java.lang.Exception 類型的異常。除了 Exception 外，方法也可以明確的指出自己可能拋出哪種類型的異常，例如：

// 示例5
public void f() throws java.io.IOException {
    ...
}

如果方法當中的某條語句可能會拋出 A 類型的異常，那么方法就不能聲明為拋出 B 類型的異常。下面的做法是錯誤的：

// 示例6
public void g() throws java.lang.NullPointerException {
    f();
}

因為 f() 已經聲明為拋出 IOException，而 g() 并沒有將該異常捕獲，因此它也必須聲明為 “throws IOException”。如果編譯器發現這種不匹配的情況，就會拒絕編譯。

有一種情況例外，就是 B 類型的異常是 A 類型的異常的父類。這意味著 B 類型的異常在業務邏輯上涵蓋了 A 類型，所以我們相信凡是能處理 B 的自然也能處理 A。

因此，既然 java.lang.Exception 是所有異常的父類，那么凡是聲明拋出該類型異常的方法，自然可以拋出任意類型的異常。也就是說，當一個方法聲明為 “throws Exception” 時，它可以拋出任何類型的異常。注意，因為這種聲明方式會給方法的調用者帶來困擾，所以我們盡量不要這么做。

  
回顧一下示例 3：

  現在回顧一下示例 3 中 catch(IOException e) {...} 部分。如果將它改為 catch(Exception e) {...}，就表示捕獲所有類型的異常，即它前面的 try 部分不論拋出什么類型的異常，它都可以處理。某些情況下這樣做是合理的，因為我們不希望當遇到某個特定種類的異常時，程序終止運行。

Java 異常入門(2/2)