你必須要知道的Java 異常的捕獲與處理（詳解附源碼）

一、異常的產生

異常是程序之中導致程序中斷的一種指令流，異常一旦出現並且沒有進行合理處理的話，那麼程序就將中斷執行。

下面，通過兩個程序來進行異常產生問題的對比。

（1）不產生異常的程序：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        int result = 10 / 2;
        System.out.println("2、除法計算結果：" + result);
        System.out.println("3、除法計算結束。");
    }
}

運行結果：

1、除法計算開始。
2、除法計算結果：5
3、除法計算結束。

（2）產生異常的程序

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        int result = 10 / 0; // 會出現錯誤
        System.out.println("2、除法計算結果：" + result);
        System.out.println("3、除法計算結束。");
    }
}

運行結果：

1、除法計算開始。Exception in thread "main" 
java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:4)

一旦產生異常，我們發現產生異常的語句以及之後的語句將不再執行，默認情況下是進行異常信息的輸出，而後自動結束程序的執行。

現在，我們要做的是：即使程序出現了異常，也要讓程序正確的執行完畢。

二、異常的處理

如果希望程序出現異常之後程序依然可以正常的完成的話，那麼就可以使用如下的格式進行異常的處理：

try {
         可能出現異常的語句 ;
} [ catch (異常類型 異常對象) {
         處理異常 ;
} catch (異常類型 異常對象) {
         處理異常 ;
} ... ] [finally {
         不管是否出現異常，都執行此代碼 ;
}]

現在，使用以上的操作處理異常處理前面除法於是出現的異常：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        try {
            int result = 10 / 0; // 異常
            System.out.println("2、除法計算結果：" + result); // 之前語句有異常，此語句不再執行
        } catch (ArithmeticException e) {
            System.out.println(e); // 異常處理：輸出錯誤信息，java.lang.ArithmeticException:/ by zero
        }
        System.out.println("3、除法計算結束。");
    }
}

運行結果：

1、除法計算開始。
java.lang.ArithmeticException: / by zero
3、除法計算結束。

可以發現，加入了異常處理之後，程序中即使有了異常，程序也可以正常的執行完畢，但是異常處理時的錯誤輸出信息和之前相比，出錯的信息不明確了，那麼爲了讓錯誤的信息更加的完整，一般都會調用printStackTrace()方法進行異常信息的打印，這個方法打印的異常信息是最完整的：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        try {
            int result = 10 / 0; // 異常
            System.out.println("2、除法計算結果：" + result); // 之前語句有異常，此語句不再執行
        } catch (ArithmeticException e) {
            e.printStackTrace(); // 異常處理：輸出錯誤信息
        }
        System.out.println("3、除法計算結束。");
    }
}

運行結果：

1、除法計算開始。
java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:5)
3、除法計算結束。

此時發現，打印的信息是很完整的。

除了try…catch格式處理異常外，還可以使用try…catch…finally:

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        try {
            int result = 10 / 1;
            System.out.println("2、除法計算結果：" + result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出現異常都執行");
        }
        System.out.println("3、除法計算結束。");
    }
}

運行結果：

1、除法計算開始。
2、除法計算結果：10
不管是否出現異常都執行
3、除法計算結束。

但是，對於之前的程序又有了問題：現在執行數學計算的兩個參數，都是由程序默認提供，那麼如果說現在兩個計算的參數通過初始化參數傳遞呢？

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        try {
            int x = Integer.parseInt(args[0]); // 接收參數
            int y = Integer.parseInt(args[1]); // 接收參數
            int result = x / y;
            System.out.println("2、除法計算結果：" + result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出現異常都執行");
        }
        System.out.println("3、除法計算結束。");
    }
}

這個時候，數據由外部傳送，那麼就有可能出現以下幾類問題：

（1）執行時不輸入參數（java TestDemo），ArrayIndexOutOfBoundsException，未處理；

（2）輸入的參數不是數字（java TestDemo a b），NumberFormatException，未處理；

（3）被除數爲0（java TestDemo 10 0），ArithmeticException，已處理。

可以發現，以上的程序實際上是存在三種異常，而程序之中只能夠處理一種，而對於不能處理的異常，發現程序依然會直接中斷執行。

加入多個catch：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        try {
            int x = Integer.parseInt(args[0]);
            int y = Integer.parseInt(args[1]);
            int result = x / y;
            System.out.println("2、除法計算結果：" + result);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出現異常都執行");
        }
        System.out.println("3、除法計算結束。");
    }
}

現在，程序比之前更健壯了。

三、異常的處理流程

以上已經完成了異常的基本處理，但是所有的異常都像之前那樣一條條的判斷似乎是一件不可能完成的任務，因爲日後肯定會接觸到一些不常見的異常信息，那麼下面就必須首先研究異常的流程和結構。

先查看兩個異常類的繼承結構：

（1）ArithmeticException：

java.lang.Object
    |- java.lang.Throwable
         |- java.lang.Exception
              |- java.lang.RuntimeException
                 |- java.lang.ArithmeticException

（2）ArrayIndexOutOfBoundsException：

java.lang.Object
   |- java.lang.Throwable
      |- java.lang.Exception
         |- java.lang.RuntimeException
             |- java.lang.IndexOutOfBoundsException
                |-java.lang.ArrayIndexOutOfBoundsException

可以發現，所有的異常類型最高的繼承類是Throwable，Throwable下有兩個子類：

（1）Error：指的是JVM錯誤，這個時候的程序並沒有執行，無法處理；

（2）Exception：指的是程序之中出現的錯誤信息，可以進行異常處理。

通過繼承關係可以發現，在進行日後異常處理的時候是以Exception爲主，並且可以形成以下的異常處理流程：

（1）如果程序中產生了異常，那麼JVM根據異常的類型，實例化一個指定異常類的對象；

（2）如果這時程序中沒有任何的異常處理操作，則這個異常類的實例化對象將交給JVM進行處理，而JVM的默認處理方式就是進行異常信息的輸出，而後中斷程序執行；

（3）如果程序中存在了異常處理，則會由try語句捕獲產生的異常類對象；

（4）與try之後的每一個catch進行匹配，如果匹配成功，則使用指定的catch進行處理，如果沒有匹配成功，則向後面的catch繼續匹配，如果沒有任何的catch匹配成功，則這個時候將交給JVM執行默認處理；

（5）不管是否有異常都會執行finally程序，如果此時沒有異常，執行完finally，則會繼續執行程序之中的其他代碼，如果此時有異常沒有能夠處理（沒有一個catch可以滿足），那麼也會執行finally，但是執行完finally之後，將默認交給JVM進行異常的信息輸出，並且程序中斷。

通過以上的分析可以發現，實際上catch捕獲異常類型的操作，就和方法接收參數是一樣的，那麼按照之前所學習過的對象多態性來講，所有的異常類都是Exception的子類，那麼這個時候，實際上所有的異常都可以使用Exception進行接收：

public class Test {
    public static void main(String args[]) {
        System.out.println("1、除法計算開始。");
        try {
            int x = Integer.parseInt(args[0]);
            int y = Integer.parseInt(args[1]);
            int result = x / y;
            System.out.println("2、除法計算結果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出現異常都執行");
        }
        System.out.println("3、除法計算結束。");
    }
}

這時應該可以感受到異常處理所帶來的好處了。但是這種操作也存在一種問題：如果在一些異常處理要求嚴格的項目之中，異常必須分別處理，如果現在異常的處理要求不是很嚴格，直接編寫Exception就足夠了。