一、異常的產生

異常是程序之中導致程序中斷的一種指令流，異常一旦出現并且沒有進行合理處理的話，那么程序就將中斷執(zhí)行。
下面，通過兩個程序來進行異常產生問題的對比。
（1）不產生異常的程序：

運行結果：

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

（2）產生異常的程序

運行結果：

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

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

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

二、異常的處理

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

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

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

運行結果：

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

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

運行結果：

此時發(fā)現，打印的信息是很完整的。

除了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('不管是否出現異常都執(zhí)行');        }        System.out.println('3、除法計算結束。');    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

運行結果：

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

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('不管是否出現異常都執(zhí)行');        }        System.out.println('3、除法計算結束。');    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

這個時候，數據由外部傳送，那么就有可能出現以下幾類問題：
（1）執(zhí)行時不輸入參數（java TestDemo），ArrayIndexOutOfBoundsException，未處理；
（2）輸入的參數不是數字（java TestDemo a b），NumberFormatException，未處理；
（3）被除數為0（java TestDemo 10 0），ArithmeticException，已處理。
可以發(fā)現，以上的程序實際上是存在三種異常，而程序之中只能夠處理一種，而對于不能處理的異常，發(fā)現程序依然會直接中斷執(zhí)行。
加入多個catch：

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

三、異常的處理流程

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

先查看兩個異常類的繼承結構：
（1）ArithmeticException：

java.lang.Object    |- java.lang.Throwable         |- java.lang.Exception              |- java.lang.RuntimeException                 |- java.lang.ArithmeticException
1
2
3
4
5

（2）ArrayIndexOutOfBoundsException：

可以發(fā)現，所有的異常類型最高的繼承類是Throwable，Throwable下有兩個子類：
（1）Error：指的是JVM錯誤，這個時候的程序并沒有執(zhí)行，無法處理；
（2）Exception：指的是程序之中出現的錯誤信息，可以進行異常處理。

通過繼承關系可以發(fā)現，在進行日后異常處理的時候是以Exception為主，并且可以形成以下的異常處理流程：

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

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

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

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

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

通過以上的分析可以發(fā)現，實際上catch捕獲異常類型的操作，就和方法接收參數是一樣的，那么按照之前所學習過的對象多態(tài)性來講，所有的異常類都是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('不管是否出現異常都執(zhí)行');        }        System.out.println('3、除法計算結束。');    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

未完待續(xù)。。。