一、簡介

描述：

例外（Exception）指不期而至的各種狀況，例外發生的原因有很多，通常包含以下幾大類：
- 用戶輸入了非法資料，
- 要打開的檔案不存在，
- 網路通信時連接中斷，或者JVM記憶體溢位，
例外是一個事件，它發生在程式運行期間，干擾了正常的指令流程，
Java語言在設計的當初就考慮到這些問題，提出例外處理的框架的方案，所有的例外都可以用一個例外類來表示，不同型別的例外對應不同的子類例外（目前我們所說的例外包括錯誤概念），定義例外處理的規范，在 JDK1.4 版本以后增加了例外鏈機制，從而便于跟蹤例外，
Java例外是一個描述在代碼段中發生例外的物件，當發生例外情況時，一個代表該例外的物件被創建并且在導致該例外的方法中被拋出，而該方法可以選擇自己處理例外或者傳遞該例外，
Java例外處理本質：拋出例外和捕獲例外，

分類：

檢查性例外：最具代表的檢查性例外是用戶錯誤或問題引起的例外，這是程式員無法預見的，例如要打開一個不存在檔案時，一個例外就發生了，這些例外在編譯時不能被簡單地忽略，
運行時例外： 運行時例外是可能被程式員避免的例外，與檢查性例外相反，運行時例外可以在編譯時被忽略，
錯誤： 錯誤不是例外，而是脫離程式員控制的問題，錯誤在代碼中通常被忽略，例如，當堆疊溢位時，一個錯誤就發生了，它們在編譯也檢查不到的，

二、例外體系

描述：

Java把例外當作物件來處理，并定義一個'java.lang.Throwable' 類作為所有例外的父類，
在Java API中已經定義了許多例外類，這些例外類分為兩大類，錯誤（Error）和例外（Exception），
'Error'表示不希望被程式捕獲或者是程式無法處理的錯誤，
'Exception'表示用戶程式可能捕捉的例外情況或者說是程式可以處理的例外，'Exception'又分為運行時例外（RuntimeException）和非運行時例外，
Java例外（Exception）又可以分為不受檢查例外（Unchecked Exception）和檢查例外（Checked Exception），

圖示：

Java例外層次結構圖

三、例外的區別與聯系

Ⅰ、Error與Exception

Error:

'Error'類物件由Java虛擬機生成并拋出，大多數錯誤與代碼撰寫者所執行的操作無關，
例如 Java虛擬機運行錯誤（VirtualMachineError），當JVM不再有繼續執行操作所需的記憶體資源時，將出現'OutOfMemoryError'，這些例外發生時，Java虛擬機（JVM）一般會選擇執行緒終止；還有發生在虛擬機試圖執行應用時，如類定義錯誤（NoClassDefFoundError）、鏈接錯誤（LinkageError），這些錯誤是不可查的，因為它們在應用程式的控制和處理能力之外，而且絕大多數是程式運行時不允許出現的狀況，
對于設計合理的應用程式來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的例外狀況，
在Java中，錯誤通常是使用'Error'的子類描述，

Exception:

在 Exception 分支中有一個重要的子類'RuntimeException'運行時例外，該型別的例外會自動為你所撰寫的程式定義例外（'ArrayIndexOutOfBoundsException'陣列下標越界、'NullPointerException'空指標、'ArithmeticException'算術例外、'MissingResourceException'丟失資源、'ClassNotFoundException'找不到類等），這些例外是不受檢查例外，程式中可以選擇捕獲處理，也可以不處理，
'RuntimeException'一般是由程式邏輯錯誤引起的，程式應該從邏輯角度盡可能避免這類例外的發生；而'RuntimeException'之外的例外（Exception）我們統稱為非運行時例外，型別上屬于'Exception'類及其子類，從程式語法角度講是必須進行處理的例外，如果不處理，程式就不能編譯通過，因此又稱為檢查例外，如'IOException'、'SQLException'等以及用戶自定義的'Exception'例外，一般情況下不自定義檢查例外，

Ⅱ、 Unchecked Exception與Checked Exception

Unchecked Exception：

不受檢查例外包括'RuntimeException'及其子類和'Error'，
不受檢查例外為編譯器不要求強制處理的例外，

Checked Exception：

除了'RuntimeException'及其子類以外，其他的'Exception'類及其子類都屬于檢查例外，
當程式中可能出現檢查例外，要么使用'try-catch'陳述句進行捕獲，要么用'throws'子句拋出，否則編譯無法通過，
檢查例外是編譯器要求必須處置的例外，

四、例外處理機制

Ⅰ、拋出例外

描述：

要理解拋出例外，首先要明白什么是例外情形（Exception Condition）：
- 例外情形是指阻止當前方法或作用域繼續執行的問題，
- 例外情形和普通問題不同，普通問題是指在當前環境下能得到足夠的資訊，總能處理這個錯誤，
對于例外情形，已經無法繼續下去了，因為在當前環境下無法獲得必要的資訊來解決問題，你所能做的就是從當前環境中跳出，并把問題提交給上一級環境，這就是拋出例外時所發生的事情，
拋出例外后，會有幾件事隨之發生：
- 首先，是像創建普通的java物件一樣，將使用'new'在堆上創建一個例外物件，
- 然后，當前的執行路徑（已經無法繼續下去了）被終止，并且從當前環境中彈出對例外物件的參考，
- 此時，例外處理機制接管程式，并開始尋找一個恰當的地方繼續執行程式，這個恰當的地方就是例外處理程式或者例外處理器，它的任務是將程式從錯誤狀態中恢復，以使程式要么換一種方式運行，要么繼續運行下去，

示例：

public class Test {

    public void test1(Student student) {
        if (student == null) {
            /* 拋出一個不受檢查例外時,方法宣告上不需要強制宣告該例外 */
            throw new RuntimeException();
        }
        System.out.println(student.name);
    }

    public void test2(Student student) throws Exception {
        if (student == null) {
            /* 拋出一個受檢查例外時,方法宣告必須宣告該例外，否則編譯報錯 */
            throw new Exception();
        }
        System.out.println(student.name);
    }

    public static void main(String[] args) throws Exception {
        new Test().test1(null);
        /* main方法呼叫宣告了例外的方法，必須對該例外進行處理，否則編譯報錯 */
        new Test().test2(null);
    }
}

class Student {
    String name;
}

Ⅱ、捕獲例外

描述：

在方法拋出例外之后，運行時系統將轉為尋找合適的例外處理器（exception handler），
潛在的例外處理器是例外發生時依次存留在呼叫堆疊中的方法的集合，當例外處理器所能處理的例外型別與方法拋出的例外型別相符時，即為合適的例外處理器，
運行時系統從發生例外的方法開始，依次回查呼叫堆疊中的方法，直至找到含有合適例外處理器的方法并執行，
當運行時系統遍歷呼叫堆疊而未找到合適的例外處理器，則運行時系統終止，同時，意味著Java程式的終止，

注意：

對于運行時例外（RuntimeException）、錯誤（Error）和檢查例外（Checked Exception），Java技術所要求的例外處理方式有所不同，
- 由于運行時例外及其子類的不可查性，為了更合理、更容易地實作應用程式，Java規定，運行時例外將由Java運行時系統自動拋出，允許應用程式忽略運行時例外，
- 對于方法運行中可能出現的錯誤，當運行方法不欲捕捉時，Java允許該方法不做任何拋出宣告，因為，大多數Error例外屬于永遠不能被允許發生的狀況，也屬于合理的應用程式不該捕捉的例外，
- 對于所有的檢查例外，Java規定：一個方法必須捕捉，或者宣告拋出方法之外，也就是說，當一個方法選擇不捕捉檢查例外時，它必須宣告將拋出例外，

Ⅲ、例外處理關鍵字

try
- 用于監聽，將要被監聽的代碼（可能拋出例外的代碼）放在'try'陳述句塊之內，當'try'陳述句塊內發生例外時，例外就被拋出，
catch
- 用于捕獲例外，'catch'用來捕獲'try'陳述句塊中發生的例外，
finally
- 'finally'陳述句塊總是會被執行，它主要用于回收在'try'塊里打開的物力資源（如資料庫連接、網路連接和磁盤檔案），只有'finally'塊，執行完成之后，才會回來執行'try'或者'catch'塊中的'return'或者'throw'陳述句，如果'finally'中使用了'return'或者'throw'等終止方法的陳述句，則就不會跳回執行，直接停止，
throw
- 用于在方法體中拋出例外，
throws
- 用在方法簽名中，用于宣告該方法可能拋出的例外，

五、處理例外

Ⅰ、try-catch

描述：

要明白例外捕獲，還要理解監控區域（guarded region）的概念，它是一段可能產生例外的代碼，并且后面跟著處理這些例外的代碼，
'try-catch'所描述的即是監控區域，關鍵詞'try'后的一對大括號將一塊可能發生例外的代碼包起來，即為監控區域，Java方法在運行程序中發生了例外，則創建例外物件，
將例外拋出監控區域之外，由Java運行時系統負責尋找匹配的'catch'子句來捕獲例外，若有一個'catch'陳述句匹配到了，則執行該'catch'塊中的例外處理代碼，就不再嘗試匹配別的'catch'塊了，
匹配原則：如果拋出的例外物件屬于'catch'子句的例外類，或者屬于該例外類的子類，則認為生成的例外物件與'catch'塊捕獲的例外型別相匹配，

多重'catch'陳述句：

很多情況下，由單個的代碼段可能引起多個例外，
處理這種情況，我們需要定義兩個或者更多的'catch'子句，每個子句捕獲一種型別的例外，當例外被引發時，每個'catch'子句被依次檢查，第一個匹配例外型別的子句執行，當一個'catch'子句執行以后，其他的子句將被跳過，
撰寫多重'catch'陳述句塊時注意'catch'子句捕獲的例外的順序：先小后大，即先子類后父類，否則，捕獲底層例外類的'catch'子句將可能會被屏蔽，

嵌套'try'陳述句：

'try'陳述句可以被嵌套，也就是說，一個'try'陳述句可以在另一個'try'塊的內部，
每次進入'try'陳述句，例外的前后關系都會被推入堆疊，如果一個內部的'try'陳述句不含特殊例外的'catch'處理程式，堆疊將彈出，下一個'try'陳述句的'catch'處理程式將檢查是否與之匹配，這個程序將繼續直到一個'catch'陳述句被匹配成功，或者是直到所有的嵌套'try'陳述句被檢查完畢，如果沒有'catch'陳述句匹配，Java運行時系統將處理這個例外，
當有方法呼叫時，'try'陳述句的嵌套可以很隱蔽的發生，例如，我們可以將對方法的呼叫放在一個'try'塊中，在該方法的內部，有另一個'try'陳述句，在這種情況下，方法內部的'try'陳述句仍然是嵌套在外部呼叫該方法的'try'塊中的，

語法：

try {
    /* 監控區域，可能產生例外的代碼 */
} catch (FirstExceptionType e1) {
    /* 指定例外型別的例外e1的處理代碼 */
} catch (SecondExceptionType e2) {
    /* 指定例外型別的例外e2的處理代碼 */
}

示例：

class Test {
    static void nestTry(int a) {
        try {
            /* 當命令列編譯運行該java檔案時有一個引數的話，使此方法產生算術運算例外 */
            if (a == 1) {
                a = a / (a - a);
            }
            /* 當命令列編譯運行該java檔案時有兩個引數的話，使此方法產生陣列越界例外 */
            if (a == 2) {
                int c[] = {1};
                c[42] = 99;
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBounds :" + e);
        }
    }

    public static void main(String[] args) {
        try {
            /* 當命令列編譯運行該java檔案時沒有引數的話，使此方法產生算術運算例外 */
            int a = args.length;
            int b = 42 / a;
            System.out.println("a = " + a);
            nestTry(a);
            /* 多重'catch'陳述句塊捕獲的例外的順序：先小后大，即先子類后父類， */
        } catch (ArithmeticException e) {
            System.out.println("Divide by 0 :" + e);
        } catch (Exception e) {
            /* Throwable類多載了Object類的toString()方法，所以列印e呼叫其toString()方法將回傳一個包含例外描述的字串， */
            System.out.println(e);
        }
    }
}

CMD測驗：

D:\studyworkspace\test\src\main\java\com\conyoo\test>javac Test.java

D:\studyworkspace\test\src\main\java\com\conyoo\test>cd ../../..

D:\studyworkspace\test\src\main\java>java com.conyoo.test.Test
Divide by 0 :java.lang.ArithmeticException: / by zero

D:\studyworkspace\test\src\main\java>java com.conyoo.test.Test 1
a = 1
Divide by 0 :java.lang.ArithmeticException: / by zero

D:\studyworkspace\test\src\main\java>java com.conyoo.test.Test 1 1
a = 2
ArrayIndexOutOfBounds :java.lang.ArrayIndexOutOfBoundsException: 42

D:\studyworkspace\test\src\main\java>

Ⅱ、throw

描述：

除了Java運行時系統自動創建的例外物件，我們還可以用'throw'陳述句拋出明確的例外，
'throw'陳述句拋出的一定是'Throwable'型別別或者'Throwable'子型別別的一個物件，
'throw'陳述句拋出的例外物件有兩種來源：使用'catch'子句中的引數，或者使用'new'運算子創建，
程式執行完'throw'陳述句之后立即停止，'throw'后面的任何陳述句不會執行，最鄰近的'try'塊會用來檢查是否含有一個與例外型別匹配的'catch'陳述句，如果發現了匹配的'catch'塊，轉向執行該'catch'塊里的陳述句；如果沒有發現，次包圍的'try'塊來檢查，以此類推，如果沒有發現匹配的'catch'塊，默認例外處理程式會中斷程式的執行，并且列印堆疊軌跡，

語法：

throw ThrowableInstance;

示例：

/*
	運行結果為在控制臺依次列印：
		例外物件在test方法里被catch，
		例外物件在main方法里被catch，java.lang.NullPointerException: 一個空指標例外物件
*/
class Test {
    static void test() {
        try {
            /* 
                所有的Java內置的運行時例外有兩個構造方法：一個沒有引數，一個帶有一個字串引數，
                當用第二種形式時，該引數應當為描述例外的字串，
                該字串會被賦值給Throwable類的屬性detailMessage，
                這樣Throwable類定義的getMessage()和Throwable類重寫的toString()等方法中，都會使用該字串，
            */
            throw new NullPointerException("一個空指標例外物件");
        } catch (NullPointerException e) {
            System.out.println("例外物件在test方法里被catch，");
            throw e;
        }
    }

    public static void main(String[] args) {
        try {
            test();
        } catch (NullPointerException e) {
            System.out.println("例外物件在main方法里被catch，" + e);
        }
    }
}

Ⅲ、throws

描述：

如果一個方法可以導致一個例外，但不在該方法中處理此例外，則該方法應當指定這種不處理的行為（若例外為檢查例外則必須指定），以使該方法的呼叫者可以保護自身而不發生例外，要做到這點，我們可以在該方法的宣告中包含一個'throws'子句，
一個'throws'子句可以列舉一個方法可能引發的所有例外型別，

注意：

如果是不受檢查例外（unchecked exception），即Error、RuntimeException或它們的子類，那么可以不使用throws關鍵字來宣告要拋出的例外，編譯仍能順利通過，但在運行時會被系統拋出，
必須宣告方法可拋出的任何檢查例外（checked exception），即如果一個方法可能出現檢查例外，要么用try-catch陳述句捕獲，要么用throws子句宣告將它拋出，否則會導致編譯錯誤，
僅當拋出了例外，該方法的呼叫者才必須處理或者重新拋出該例外，當方法的呼叫者無力處理該例外的時候，應該繼續拋出，而不是囫圇吞棗，
若重寫一個方法，子類方法宣告的例外型別，不能為'被重寫方法宣告的例外型別'的父類，可以為同一型別或其子類，也可以另外再宣告，不在'被重寫方法宣告的例外型別'的直系繼承關系中的，其他型別例外，

語法：

/*  Throwable是該方法可能引發的例外,也可以是例外串列，中間以逗號隔開， */
public void function() throws Throwable {}

示例：

class Test1 {
    void test() throws IllegalAccessException {
        throw new IllegalAccessException("IllegalAccessException1");
    }

    public static void main(String[] args) {
        try {
            new Test2().test();
        } catch (Exception e) {
            System.out.println(e);//java.lang.IllegalAccessException: IllegalAccessException2
        }
    }
}

class Test2 extends Test1 {
    /* throws可以另外再宣告，不在'被重寫方法宣告的例外型別'的直系繼承關系中的，其他型別例外， */
    void test() throws NegativeArraySizeException, IllegalAccessException {
        throw new IllegalAccessException("IllegalAccessException2");
    }
}

Ⅳ、finally

描述：

當例外發生時，通常方法的執行將做一個陡峭的非線性的轉向，它甚至會過早地導致方法回傳，例如，如果一個方法打開了一個檔案并關閉，然后退出，你不希望關閉檔案的代碼被例外處理機制所跳過，就可以使用'finally'關鍵字，
一個方法，將從內部的'try-catch'塊回傳到其呼叫者處前，即經過一個未捕獲的例外或者是一個明確的回傳陳述句前，'finally'子句會執行，這在關閉檔案句柄，和釋放任何在方法開始時被分配的其他資源時很有用，

注意：

'finally'代碼塊在所屬'try-catch'塊將完成之時，其他'try-catch'塊出現之前執行，
'finally'塊無論所在監控區域有沒有例外拋出都會執行，如果拋出例外，即使沒有'catch子句匹配，'finally'塊也會執行，
'finally'子句是可選項，可以有也可以無，但是每個'try'陳述句至少需要一個'catch'或者'finally'子句，
如果'finally'塊與一個'try'塊（沒有'catch'塊）聯合使用，finally塊將在'try'塊結束之前執行，
如果存在'finally'代碼塊，'try'中的'return'陳述句不會立馬回傳呼叫者，而是記錄下回傳值待'finally'代碼塊執行完畢之后再向呼叫者回傳其值，這樣如果在'finally'中修改了回傳值，就會回傳修改后的值，
不要在'finally'中進行'return'操作或者修改回傳值，可能會導致一些意想不到的邏輯錯誤，例如方法的呼叫者捕獲不到例外，

示例：

/*
	運行結果為在控制臺依次列印：
		inside proc1
        proc1's finally
        java.lang.RuntimeException
        inside proc2
        proc2's finally
        inside proc3
        proc3's finally
*/
class Test {
    static void proc1() {
        try {
            System.out.println("inside proc1");
            throw new RuntimeException();
        } finally {
            System.out.println("proc1's finally");
        }
    }

    static void proc2() {
        try {
            System.out.println("inside proc2");
            return;
        } finally {
            System.out.println("proc2's finally");
        }
    }

    static void proc3() {
        try {
            System.out.println("inside proc3");
        } finally {
            System.out.println("proc3's finally");
        }
    }

    public static void main(String[] args) {
        try {
            proc1();
        } catch (Exception e) {
            System.out.println(e);
        }
        proc2();
        proc3();
    }
}

Ⅴ、try、catch、finally、return執行順序

執行'try'塊里的代碼，
若'try'塊里出現例外，檢查該例外是否能被'catch'子句捕獲，若與'catch'子句宣告的例外相匹配，則執行'catch'塊里的代碼，
執行'try-catch'塊里的代碼，直到遇到向外拋出例外（該例外無法被當前'catch'子句捕獲）或'return'的陳述句，這時若有'finally'塊，則先去執行'finally'塊中的代碼，
向外拋出例外或執行'return'陳述句，

六、自定義例外

描述：

使用Java內置的例外類可以描述在編程時出現的大部分例外情況，除此之外，用戶還可以自定義例外，自定義例外類只需繼承'Exception'類即可，
在程式中使用自定義例外類，與使用Java內置的例外類基本相同，由于是自定義的例外，所以需要在代碼里主動創建該例外物件并'throw'，
使用自定義例外類大體可分為以下幾個步驟：
1. 創建自定義例外類，繼承'Exception'類或其子類，
2. 在方法中通過'throw'關鍵字拋出例外物件，
3. 如果要在當前拋出例外的方法中處理例外，可以使用'try-catch'陳述句捕獲并處理；否則在方法的宣告處，通過'throws'關鍵字指明要拋出給方法呼叫者的例外，
4. 繼續在出現例外的方法的呼叫者中捕獲處理例外或繼續拋出例外，

示例：

/*
	運行結果為在控制臺依次列印：
		Called compute(1)
        Normal exit!
        Called compute(20)
        Caught MyException [20]
*/
public class Test {
    static void compute(int a) throws MyException {
        System.out.println("Called compute(" + a + ")");
        if (a > 10) {
            throw new MyException(a);
        }
        System.out.println("Normal exit!");
    }

    public static void main(String[] args) {
        try {
            compute(1);
            compute(20);
        } catch (MyException me) {
            System.out.println("Caught " + me);
        }
    }
}

class MyException extends Exception {
    private int detail;

    MyException(int a) {
        detail = a;
    }

    public String toString() {
        return "MyException [" + detail + "]";
    }
}

七、總結

圖示：

例外總結

實際應用：

處理運行時例外時，采用邏輯去合理規避的同時，輔助'try-catch'進行處理，
在多重'catch'塊后面，可以加一個'catch (Exception e)'來處理可能會被遺漏的例外，
對于不確定的代碼，也可以加上'try-catch'處理潛在的例外，
盡量去處理例外，切忌只是簡單地呼叫'printStackTrace()'去列印輸出，
具體如何處理例外，要根據不同的業務需求和例外型別去決定，
盡量添加'finally'陳述句塊去釋放占用的資源，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/238868.html

標籤：Java

上一篇：原始碼決議Synchronized同步方法的八種使用場景，收藏

下一篇：精盡Spring MVC原始碼分析 - RequestToViewNameTranslator 組件

Java基本概念：例外

一、簡介

二、例外體系

三、例外的區別與聯系

Ⅰ、Error與Exception

Ⅱ、 Unchecked Exception與Checked Exception

四、例外處理機制

Ⅰ、拋出例外

Ⅱ、捕獲例外

Ⅲ、例外處理關鍵字

五、處理例外

Ⅰ、try-catch

Ⅱ、throw

Ⅲ、throws

Ⅳ、finally

Ⅴ、try、catch、finally、return執行順序

六、自定義例外

七、總結