全面了解java中的異常處理

更新時(shí)間：2021年08月26日 15:34:46 作者：小蝸牛耶

java中的異常處理是java語言中的一大重要特性，它分離了接收和處理錯(cuò)誤代碼。這篇文章非常詳細(xì)的講解了java中的這一特性，感興趣的小伙伴一起來學(xué)習(xí)學(xué)習(xí)吧

Java 異常處理

Java 的異常處理是 Java 語言的一大重要特性，也是提高代碼健壯性的最強(qiáng)大方法之一。當(dāng)我們編寫了錯(cuò)誤的代碼時(shí)，編譯器在編譯期間可能會(huì)拋出異常，有時(shí)候即使編譯正常，在運(yùn)行代碼的時(shí)候也可能會(huì)拋出異常。

目標(biāo)

什么是異常

Java 中異常類的架構(gòu)

如何進(jìn)行異常處理

如何自定義異常

什么是異常鏈

如何使用異常鏈

前言

1.8/25

2.編程不能停，成為運(yùn)維開發(fā)性人才

3.計(jì)算機(jī)408基礎(chǔ)打好，編程語言學(xué)精通，然后走下去

4.Docker和K8s繼續(xù)

1. 什么是異常

異常就是程序上的錯(cuò)誤，我們?cè)诰帉懗绦虻臅r(shí)候經(jīng)常會(huì)產(chǎn)生錯(cuò)誤，這些錯(cuò)誤劃分為編譯期間的錯(cuò)誤和運(yùn)行期間的錯(cuò)誤。

下面我們來看幾個(gè)常見的異常案例。

如果語句漏寫分號(hào)，程序在編譯期間就會(huì)拋出異常，實(shí)例如下：

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World!")
    }
}

運(yùn)行結(jié)果：

$ javac Hello.java
Hello.java:3: 錯(cuò)誤: 需要';'
        System.out.println("Hello World!")
                                          ^
1 個(gè)錯(cuò)誤

static 關(guān)鍵字寫成了 statci，實(shí)例如下：

Hello.java:2: 錯(cuò)誤: 需要<標(biāo)識(shí)符>
    public statci void main(String[] args) {
                 ^
1 個(gè)錯(cuò)誤

當(dāng)數(shù)組下標(biāo)越界，程序在編譯階段不會(huì)發(fā)生錯(cuò)誤，但在運(yùn)行時(shí)會(huì)拋出異常。實(shí)例如下：

public class ArrayOutOfIndex {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);
    }
}

運(yùn)行結(jié)果：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at ArrayOutOfIndex.main(ArrayOutOfIndex.java:4)

2. Java 異常類架構(gòu)

在 Java 中，通過 Throwable 及其子類來描述各種不同類型的異常。如下是 Java 異常類的架構(gòu)圖（不是全部，只展示部分類）：

2.1 Throwable 類

Throwable 位于 java.lang 包下，它是 Java 語言中所有錯(cuò)誤（Error）和異常（Exception）的父類。

Throwable 包含了其線程創(chuàng)建時(shí)線程執(zhí)行堆棧的快照，它提供了 printStackTrace() 等接口用于獲取堆棧跟蹤數(shù)據(jù)等信息。

主要方法：

fillInStackTrace：用當(dāng)前的調(diào)用棧層次填充 Throwable 對(duì)象棧層次，添加到棧層次任何先前信息中；
getMessage：返回關(guān)于發(fā)生的異常的詳細(xì)信息。這個(gè)消息在 Throwable 類的構(gòu)造函數(shù)中初始化了；
getCause：返回一個(gè) Throwable 對(duì)象代表異常原因；
getStackTrace：返回一個(gè)包含堆棧層次的數(shù)組。下標(biāo)為 0 的元素代表?xiàng)ｍ敚詈笠粋€(gè)元素代表方法調(diào)用堆棧的棧底；
printStackTrace：打印 toString() 結(jié)果和棧層次到 System.err，即錯(cuò)誤輸出流。

2.2 Error 類

Error 是 Throwable 的一個(gè)直接子類，它可以指示合理的應(yīng)用程序不應(yīng)該嘗試捕獲的嚴(yán)重問題。這些錯(cuò)誤在應(yīng)用程序的控制和處理能力之外，編譯器不會(huì)檢查 Error，對(duì)于設(shè)計(jì)合理的應(yīng)用程序來說，即使發(fā)生了錯(cuò)誤，本質(zhì)上也無法通過異常處理來解決其所引起的異常狀況。

常見 Error：

AssertionError：斷言錯(cuò)誤；
VirtualMachineError：虛擬機(jī)錯(cuò)誤；
UnsupportedClassVersionError：Java 類版本錯(cuò)誤；
OutOfMemoryError ：內(nèi)存溢出錯(cuò)誤。

2.3 Exception 類

Exception 是 Throwable 的一個(gè)直接子類。它指示合理的應(yīng)用程序可能希望捕獲的條件。

Exception 又包括 Unchecked Exception（非檢查異常）和 Checked Exception（檢查異常）兩大類別。

2.3.1 Unchecked Exception （非檢查異常）

Unchecked Exception 是編譯器不要求強(qiáng)制處理的異常，包含 RuntimeException 以及它的相關(guān)子類。我們編寫代碼時(shí)即使不去處理此類異常，程序還是會(huì)編譯通過。

常見非檢查異常：

NullPointerException：空指針異常；
ArithmeticException：算數(shù)異常；
ArrayIndexOutOfBoundsException：數(shù)組下標(biāo)越界異常；
ClassCastException：類型轉(zhuǎn)換異常。

2.3.2 Checked Exception（檢查異常）

Checked Exception 是編譯器要求必須處理的異常，除了 RuntimeException 以及它的子類，都是 Checked Exception 異常。我們?cè)诔绦蚓帉憰r(shí)就必須處理此類異常，否則程序無法編譯通過。

常見檢查異常：

IOException：IO 異常
SQLException：SQL 異常

3. 如何進(jìn)行異常處理

在 Java 語言中，異常處理機(jī)制可以分為兩部分：

1.拋出異常：當(dāng)一個(gè)方法發(fā)生錯(cuò)誤時(shí)，會(huì)創(chuàng)建一個(gè)異常對(duì)象，并交給運(yùn)行時(shí)系統(tǒng)處理；
2.捕獲異常：在方法拋出異常之后，運(yùn)行時(shí)系統(tǒng)將轉(zhuǎn)為尋找合適的異常處理器。

Java 通過 5 個(gè)關(guān)鍵字來實(shí)現(xiàn)異常處理，分別是：throw、throws、try、catch、finally。

異常總是先拋出，后捕獲的。下面我們將圍繞著 5 個(gè)關(guān)鍵字來詳細(xì)講解如何拋出異常以及如何捕獲異常。

4. 拋出異常

4.1 實(shí)例

我們先來看一個(gè)除零異常的實(shí)例代碼：

package com.caq.exception;

public class Demo01 {
    //打印a/b的結(jié)果
    public static void test(int a,int b){
        System.out.println(a/b);
    }

    public static void main(String[] args) {
        //調(diào)用test方法
        test(5,0);
    }
}

運(yùn)行結(jié)果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.caq.exception.Demo01.test(Demo01.java:6)
	at com.caq.exception.Demo01.main(Demo01.java:11)

Process finished with exit code 1

我們知道 0 是不能用作除數(shù)的，由于 test() 方法中除數(shù) b 為 0，所以代碼將停止執(zhí)行并顯示了相關(guān)的異常信息，此信息為堆棧跟蹤

上面的運(yùn)行結(jié)果告訴我們：main 線程發(fā)生了類型為 ArithmeticException 的異常，顯示消息為 by zero，并且提示了可能發(fā)生異常的方法和行號(hào)。

4.2 throw

上面的實(shí)例中，程序在運(yùn)行時(shí)引發(fā)了錯(cuò)誤，那么如何來顯示拋出（創(chuàng)建）異常呢？

我們可以使用 throw 關(guān)鍵字來拋出異常，throw 關(guān)鍵字后面跟異常對(duì)象，改寫上面的實(shí)例代碼：

package com.caq.exception;

public class Demo01 {
    //打印a/b的結(jié)果
    public static void test(int a,int b){
        if (b==0){
            //拋出異常
            throw new ArithmeticException("被除數(shù)不能為零");
        }
        System.out.println(a/b);
    }

    public static void main(String[] args) {
        //調(diào)用test方法
        test(5,0);
    }
}

運(yùn)行結(jié)果：

Exception in thread "main" java.lang.ArithmeticException: 被除數(shù)不能為零
	at com.caq.exception.Demo01.test(Demo01.java:8)
	at com.caq.exception.Demo01.main(Demo01.java:15)

代碼在運(yùn)行時(shí)同樣引發(fā)了錯(cuò)誤，但顯示消息為 “除數(shù)不能為零”。我們看到 test() 方法中加入了條件判斷，如果調(diào)用者將參數(shù) b 設(shè)置為 0 時(shí)，會(huì)使用 throw 關(guān)鍵字來拋出異常，throw 后面跟了一個(gè)使用 new 關(guān)鍵字實(shí)例化的算數(shù)異常對(duì)象，并且將消息字符串作為參數(shù)傳遞給了算數(shù)異常的構(gòu)造函數(shù)。

我們可以使用 throw 關(guān)鍵字拋出任何類型的 Throwable 對(duì)象，它會(huì)中斷方法，throw 語句之后的所有內(nèi)容都不會(huì)執(zhí)行。除非已經(jīng)處理拋出的異常。異常對(duì)象不是從方法中返回的，而是從方法中拋出的。

4.3 throws

可以通過 throws 關(guān)鍵字聲明方法要拋出何種類型的異常。如果一個(gè)方法可能會(huì)出現(xiàn)異常，但是沒有能力處理這種異常，可以在方法聲明處使用 throws 關(guān)鍵字來聲明要拋出的異常。例如，汽車在運(yùn)行時(shí)可能會(huì)出現(xiàn)故障，汽車本身沒辦法處理這個(gè)故障，那就讓開車的人來處理。

throws 用在方法定義時(shí)聲明該方法要拋出的異常類型，如下是偽代碼：

public void demoMethod() throws Exception1, Exception2, ... ExceptionN {
    // 可能產(chǎn)生異常的代碼
}

throws 后面跟的異常類型列表可以有一個(gè)也可以有多個(gè)，多個(gè)則以 , 分割。當(dāng)方法產(chǎn)生異常列表中的異常時(shí)，將把異常拋向方法的調(diào)用方，由調(diào)用方處理。

throws 有如下使用規(guī)則：

1.如果方法中全部是非檢查異常（即 Error、RuntimeException 以及的子類），那么可以不使用 throws 關(guān)鍵字來聲明要拋出的異常，編譯器能夠通過編譯，但在運(yùn)行時(shí)會(huì)被系統(tǒng)拋出；
2.如果方法中可能出現(xiàn)檢查異常，就必須使用 throws 聲明將其拋出或使用 try catch 捕獲異常，否則將導(dǎo)致編譯錯(cuò)誤；
3.當(dāng)一個(gè)方法拋出了異常，那么該方法的調(diào)用者必須處理或者重新拋出該異常；
4.當(dāng)子類重寫父類拋出異常的方法時(shí)，聲明的異常必須是父類所聲明異常的同類或子類。

5. 捕獲異常

使用 try 和 catch 關(guān)鍵字可以捕獲異常。try catch 代碼塊放在異?？赡馨l(fā)生的地方。它的語法如下：

Tips：
再IDEA里可以通過//ctrl+alt+t選擇代碼自動(dòng)包裹

try {
    // 可能會(huì)發(fā)生異常的代碼塊
} catch (Exception e1) {
    // 捕獲并處理try拋出的異常類型Exception
} catch (Exception2 e2) {
    // 捕獲并處理try拋出的異常類型Exception2
} finally {
    // 無論是否發(fā)生異常，都將執(zhí)行的代碼塊
}

我們來看一下上面語法中的 3 種語句塊：

try 語句塊：用于監(jiān)聽異常，當(dāng)發(fā)生異常時(shí)，異常就會(huì)被拋出；
catch 語句塊：catch 語句包含要捕獲的異常類型的聲明，當(dāng) try 語句塊發(fā)生異常時(shí)，catch 語句塊就會(huì)被檢查。當(dāng) catch 塊嘗試捕獲異常時(shí)，是按照 catch 塊的聲明順序從上往下尋找的，一旦匹配，就不會(huì)再向下執(zhí)行。因此，如果同一個(gè) try 塊下的多個(gè) catch 異常類型有父子關(guān)系，應(yīng)該將子類異常放在前面，父類異常放在后面；
finally 語句塊：無論是否發(fā)生異常，都會(huì)執(zhí)行 finally 語句塊。finally 常用于這樣的場景：由于 finally 語句塊總是會(huì)被執(zhí)行，所以那些在 try 代碼塊中打開的，并且必須回收的物理資源（如數(shù)據(jù)庫連接、網(wǎng)絡(luò)連接和文件），一般會(huì)放在 finally 語句塊中釋放資源。

try 語句塊后可以接零個(gè)或多個(gè) catch 語句塊，如果沒有 catch 塊，則必須跟一個(gè) finally 語句塊。簡單來說，try 不允許單獨(dú)使用，必須和 catch 或 finally 組合使用，catch 和 finally 也不能單獨(dú)使用。

實(shí)例如下：

package com.caq.exception;

public class Demo01 {
    //打印a/b的結(jié)果
    public static void test(int a,int b){

        System.out.println(a/b);
    }

    public static void main(String[] args) {
        //調(diào)用test方法
        try {
            test(5,0);
        }catch (ArithmeticException e1){
            System.out.println("捕獲的異常為："+e1);
        }finally {
            System.out.println("無論是否發(fā)送異常，我都會(huì)執(zhí)行哦~");
        }

    }
}

運(yùn)行結(jié)果：

捕獲的異常為：java.lang.ArithmeticException: / by zero
無論是否發(fā)送異常，我都會(huì)執(zhí)行哦~

test() 方法中除數(shù) b 為 0，會(huì)發(fā)生除零異常，我們?cè)诜椒ㄕ{(diào)用處使用了 try 語句塊對(duì)異常進(jìn)行捕獲；如果捕獲到了異常， catch 語句塊會(huì)對(duì) ArithmeticException 類型的異常進(jìn)行處理，此處打印了一行自定義的提示語句；

最后的 finally 語句塊，無論發(fā)生異常與否，總會(huì)執(zhí)行。

Java 7 以后，catch 多種異常時(shí)，也可以像下面這樣簡化代碼：

try {
    // 可能會(huì)發(fā)生異常的代碼塊
} catch (Exception | Exception2 e) {
    // 捕獲并處理try拋出的異常類型
} finally {
    // 無論是否發(fā)生異常，都將執(zhí)行的代碼塊
}

6. 自定義異常

自定義異常，就是定義一個(gè)類，去繼承 Throwable 類或者它的子類。

Java 內(nèi)置了豐富的異常類，通常使用這些內(nèi)置異常類，就可以描述我們?cè)诰幋a時(shí)出現(xiàn)的大部分異常情況。一旦內(nèi)置異常無法滿足我們的業(yè)務(wù)要求，就可以通過自定義異常描述特定業(yè)務(wù)產(chǎn)生的異常類型。

實(shí)例：

public class ExceptionDemo4 {

    static class MyCustomException extends RuntimeException {
        /**
         * 無參構(gòu)造方法
         */
        public MyCustomException() {
            super("我的自定義異常");
        }
    }

    public static void main(String[] args) {
      	// 直接拋出異常
        throw new MyCustomException();
    }
}

運(yùn)行結(jié)果：

Exception in thread "main" ExceptionDemo4$MyCustomException: 我的自定義異常
	at ExceptionDemo4.main(ExceptionDemo4.java:13)

在代碼中寫了一個(gè)自定義異常 MyCustomException，繼承自 RuntimeException，它是一個(gè)靜態(tài)內(nèi)部類，這樣在主方法中就可以直接拋出這個(gè)異常類了。當(dāng)然，也可以使用 catch 來捕獲此類型異常。

7. 異常鏈

異常鏈?zhǔn)且砸粋€(gè)異常對(duì)象為參數(shù)構(gòu)造新的異常對(duì)象，新的異常對(duì)象將包含先前異常的信息。簡單來說，就是將異常信息從底層傳遞給上層，逐層拋出，我們來看一個(gè)實(shí)例：

public class ExceptionDemo5 {

    /**
     * 第一個(gè)自定義的靜態(tài)內(nèi)部異常類
     */
    static class FirstCustomException extends Exception {

        // 無參構(gòu)造方法
        public FirstCustomException() {
            super("第一個(gè)異常");
        }
    }

    /**
     * 第二個(gè)自定義的靜態(tài)內(nèi)部異常類
     */
    static class SecondCustomException extends Exception {

        public SecondCustomException() {
            super("第二個(gè)異常");
        }
    }

    /**
     * 第三個(gè)自定義的靜態(tài)內(nèi)部異常類
     */
    static class ThirdCustomException extends Exception {

        public ThirdCustomException() {
            super("第三個(gè)異常");
        }
    }

    /**
     * 測試異常鏈靜態(tài)方法1，直接拋出第一個(gè)自定義的靜態(tài)內(nèi)部異常類
     * @throws FirstCustomException
     */
    public static void f1() throws FirstCustomException {
        throw new FirstCustomException();
    }

    /**
     * 測試異常鏈靜態(tài)方法2，調(diào)用f1()方法，并拋出第二個(gè)自定義的靜態(tài)內(nèi)部異常類
     * @throws SecondCustomException
     */
    public static void f2() throws SecondCustomException {
        try {
            f1();
        } catch (FirstCustomException e) {
            throw new SecondCustomException();
        }
    }

    /**
     * 測試異常鏈靜態(tài)方法3，調(diào)用f2()方法， 并拋出第三個(gè)自定義的靜態(tài)內(nèi)部異常類
     * @throws ThirdCustomException
     */
    public static void f3() throws ThirdCustomException {
        try {
            f2();
        } catch (SecondCustomException e) {
            throw new ThirdCustomException();
        }
    }

    public static void main(String[] args) throws ThirdCustomException {
        // 調(diào)用靜態(tài)方法f3()
        f3();
    }
}

運(yùn)行結(jié)果：

Exception in thread "main" ExceptionDemo5$ThirdCustomException: 第三個(gè)異常
	at ExceptionDemo5.f3(ExceptionDemo5.java:46)
	at ExceptionDemo5.main(ExceptionDemo5.java:51)

通過運(yùn)行結(jié)果，我們只獲取到了靜態(tài)方法 f3() 所拋出的異常堆棧信息，前面代碼所拋出的異常并沒有被顯示。

我們改寫上面的代碼，讓異常信息以鏈條的方式 “連接” 起來?？梢酝ㄟ^改寫自定義異常的構(gòu)造方法，來獲取到之前異常的信息。實(shí)例如下：

public class ExceptionDemo6 {

    /**
     * 第一個(gè)自定義的靜態(tài)內(nèi)部異常類
     */
    static class FirstException extends Exception {

        // 無參構(gòu)造方法
        public FirstException() {
            super("第一個(gè)異常");
        }

    }

    /**
     * 第二個(gè)自定義的靜態(tài)內(nèi)部異常類
     */
    static class SecondCustomException extends Exception {

        /**
         * 通過構(gòu)造方法獲取之前異常的信息
         * @param cause 捕獲到的異常對(duì)象
         */
        public SecondCustomException(Throwable cause) {
            super("第二個(gè)異常", cause);
        }
    }

    /**
     * 第三個(gè)自定義的靜態(tài)內(nèi)部異常類
     */
    static class ThirdCustomException extends Exception {

        /**
         * 通過構(gòu)造方法獲取之前異常的信息
         * @param cause 捕獲到的異常對(duì)象
         */
        public ThirdCustomException(Throwable cause) {
            super("第三個(gè)異常", cause);
        }
    }

    /**
     * 測試異常鏈靜態(tài)方法1，直接拋出第一個(gè)自定義的靜態(tài)內(nèi)部異常類
     * @throws FirstException
     */
    public static void f1() throws FirstException {
        throw new FirstException();
    }

    /**
     * 測試異常鏈靜態(tài)方法2，調(diào)用f1()方法，并拋出第二個(gè)自定義的靜態(tài)內(nèi)部異常類
     * @throws SecondCustomException
     */
    public static void f2() throws SecondCustomException {
        try {
            f1();
        } catch (FirstException e) {
            throw new SecondCustomException(e);
        }
    }

    /**
     * 測試異常鏈靜態(tài)方法3，調(diào)用f2()方法， 并拋出第三個(gè)自定義的靜態(tài)內(nèi)部異常類
     * @throws ThirdCustomException
     */
    public static void f3() throws ThirdCustomException {
        try {
            f2();
        } catch (SecondCustomException e) {
            throw new ThirdCustomException(e);
        }
    }

    public static void main(String[] args) throws ThirdCustomException {
        // 調(diào)用靜態(tài)方法f3()
        f3();
    }
}

運(yùn)行結(jié)果：

Exception in thread "main" ExceptionDemo6$ThirdCustomException: 第三個(gè)異常
	at ExceptionDemo6.f3(ExceptionDemo6.java:74)
	at ExceptionDemo6.main(ExceptionDemo6.java:80)
Caused by: ExceptionDemo6$SecondCustomException: 第二個(gè)異常
	at ExceptionDemo6.f2(ExceptionDemo6.java:62)
	at ExceptionDemo6.f3(ExceptionDemo6.java:72)
	... 1 more
Caused by: ExceptionDemo6$FirstException: 第一個(gè)異常
	at ExceptionDemo6.f1(ExceptionDemo6.java:51)
	at ExceptionDemo6.f2(ExceptionDemo6.java:60)
	... 2 more

通過運(yùn)行結(jié)果，我們看到，異常發(fā)生的整個(gè)過程都打印到了屏幕上，這就是一個(gè)異常鏈。