一. 異常機制簡介

1. 異常概念

所謂的異常，其實就是各種“意外”，是指在程序執(zhí)行期間發(fā)生的“意外事件”，它中斷了正在執(zhí)行程序的正常指令流，沒有產(chǎn)生我們預(yù)期中的結(jié)果。就好比我們的生活中，也會經(jīng)常有一些意外發(fā)生。本來你計劃今天和女朋友去happy，結(jié)果你的領(lǐng)導(dǎo)非要你去加班，不加班就辭退，這就是預(yù)期外的異常事件。

Java給我們提供了專門的異常類來處理異常。在一個方法的運行過程中，如果發(fā)生了異常，這個方法會產(chǎn)生代表該異常的一個對象，并把它交給運行時系統(tǒng)，運行時系統(tǒng)會尋找相應(yīng)的代碼來處理該異常。Java把異常提交給運行時系統(tǒng)的過程稱為拋出(throw)異常，運行時系統(tǒng)在方法的調(diào)用棧中查找到處理該異常對象的過程稱為捕獲(catch)異常。

2. 產(chǎn)生原因

在Java中，一個異常的產(chǎn)生主要有以下幾種原因：

• Java內(nèi)部錯誤導(dǎo)致了異常，比如Java虛擬機自身出現(xiàn)了問題；
• 我們自己編寫的代碼有問題，例如空指針異常、數(shù)組越界異常等；
• 項目運行所依賴的外部數(shù)據(jù)、網(wǎng)絡(luò)環(huán)境等有問題，導(dǎo)致項目產(chǎn)生了故障；
• 通過throw等語句主動生成異常，主要用來告知該方法的調(diào)用者一些必要信息。

3. 異常類型

我們現(xiàn)在知道，Java中有專門的異常處理類，而這些異常類其實都是java.lang.Throwable的子類，所以Throwable是所有異常類的“老祖宗”。 從整體上來看，Throwable類中有兩個異常分支，即Exception和Error。如下圖所示：

從上圖中我們可知，Throwable是所有異常和錯誤的父類，Error和 Exception兩個子類分別表示錯誤和異常。

其中，Error錯誤是在程序執(zhí)行期間發(fā)生的嚴(yán)重問題，例如虛擬機崩潰、堆棧溢出錯誤、內(nèi)存溢出等。這些錯誤一般是正常情況下不大可能出現(xiàn)的，絕大部分的Error都會導(dǎo)致程序處于非正常、不可恢復(fù)的狀態(tài)，而我們也無法處理這些錯誤，只能盡力避免它們的發(fā)生，所以一般也不需要被開發(fā)者捕獲處理。

而Exception類則用于處理用戶程序可能出現(xiàn)的異常。根據(jù)異常的產(chǎn)生時機，該類可以細分為運行時異常(Runtime Exception)和非運行時異常(UnRuntime Exception) ；或者根據(jù)是否檢查，又可以叫做非受檢異常(Unchecked Exception)和受檢異常(Checked Exception) 。

• 運行時異常都是RuntimeException類及其子類，如NullPointerException、IndexOutOfBoundsException、ArithmeticException等。這些異常是在運行時才會被發(fā)現(xiàn)的異常，它們通常是由于程序員的錯誤引起的，例如除零、數(shù)組越界等。我們在程序中可以選擇捕獲處理，也可以不處理，但應(yīng)該盡力避免它們發(fā)生。另外因為這些異常在編譯階段通常不會進行異常的檢查，所以也被稱為非受檢異常。
• 非運行時異常是指RuntimeException以外的異常，它們都是Exception類及其子類。這些異常是在編譯階段就被檢查的異常，也稱為受檢異常。它們通常是由于外部因素引起的，例如輸入/輸出錯誤、網(wǎng)絡(luò)連接問題或文件找不到等。我們必須處理這些異常，否則編譯時就會出錯而無法通過，如IOException、SQLException、ClassNotFoundException及用戶自定義的Exception等異常(我們一般不會自定義檢查異常)。

4. 小結(jié)

綜上述所， java.lang.Throwable是Java中的異常父類，包括Error和Exception兩大子類。并且在Java代碼中，只有繼承了Throwable類的實例，才能被throw拋出或者catch捕獲。

4.1 Error與Exception的區(qū)別

Error是正常情況下不大可能出現(xiàn)的情況，屬于未檢查類型，大多數(shù)發(fā)生在運行時。另外絕大部分的Error都會導(dǎo)致程序處于非正常、不可恢復(fù)的狀態(tài)，任何處理技術(shù)都無法恢復(fù)，肯定會導(dǎo)致程序的非正常終止，所以不需要被開發(fā)者捕獲。

而Exception是程序正常運行過程中可以預(yù)料到的意外情況，分為受檢異常和非受檢異常。受檢異常在代碼中必須進行顯式地捕獲處理，這是編譯期檢查的一部分。非受檢異常也被稱為運行時異常，通常是在編碼時就能避免的邏輯錯誤，具體根據(jù)需要來判斷是否需要捕獲，不會在編譯器強制要求，應(yīng)該被開發(fā)者捕獲進行相應(yīng)的處理。

接下來再給大家說一些常見的Error和Exception：

4.2 錯誤

• OutOfMemoryError：內(nèi)存溢出錯誤；
• VirtualMachineError：虛擬機錯誤；
• NoClassDefFoundError：找不到類定義錯誤；
• StackOverflowError：堆棧異常錯誤

4.3 運行時異常

• NullPropagation：空指針異常；
• ClassCastException：強制類型轉(zhuǎn)換異常；
• IllegalArgumentException：非法傳參異常；
• IndexOutOfBoundsException：下標(biāo)越界異常；
• NumberFormatException：數(shù)字格式化異常

4.4 非運行時異常

• ClassNotFoundException：找不到指定的類異常；
• IOException：IO操作異常

二. 異常處理機制

1. 概述

既然異常的產(chǎn)生是不可避免的，那么為了保證程序有效地執(zhí)行，我們就需要對發(fā)生的異常進行相應(yīng)的處理。否則當(dāng)Java程序發(fā)生異常時，可能會導(dǎo)致程序的停止或故障。而Java給我們提供了一套完整的異常處理機制，來應(yīng)對可能出現(xiàn)的各種問題。在Java中，異常處理主要是利用5個關(guān)鍵字來實現(xiàn)：

try、catch、throw、throws、finally

其中，try catch語句用于捕獲并處理異常，finally語句用于在任何情況下(除特殊情況外)都必須執(zhí)行的代碼，throw語句用于拋出異常，throws語句用于聲明可能會出現(xiàn)的異常。

總之，Java的異常處理機制給我們提供了一種結(jié)構(gòu)性和控制性的方式，來處理程序執(zhí)行期間發(fā)生的事件?？傮w上來說，對異常的處理其實就是“要么捕獲，要么拋出” ，這好比我們對待一個犯了錯誤的孩子，要么抓住他修理一頓，要么把他扔給別人處理，而自己不管不問。所以我們對異常的處理思路如下：

• 捕獲異常：在方法中用 try catch語句捕獲并處理異常，catch語句可以有多個，用來匹配多個異常；
• 拋出異常：對處理不了的異?；蛘咭D(zhuǎn)型的異常，在方法的聲明處可以通過throws語句拋出異常，即由上層的調(diào)用方法進行處理。

接下來再分別細說一下異常處理機制。

2. 捕獲異常

很多時候，我們對異常的處理就是進行捕獲，所以Java給我們提供了try-catch語句來捕獲異常。如果我們編寫的某些代碼，可能會拋出異常，那你就可以用try語句塊把這些代碼包裹起來。而catch語句塊中包含了處理異常的代碼，所以如果一個異常被拋出，它就可以被catch語句塊捕獲并處理。

try {
    // 可能會拋出異常的代碼
} catch (ExceptionType1 e1) {
    // 異常處理代碼
} catch (ExceptionType2 e2) {
    // 異常處理代碼
} finally {
    // finally塊是可選的，并不是必須的，不管是否發(fā)生異常，這里的代碼都會被執(zhí)行
}

在try語句塊中，我們可以編寫多個語句，包括方法調(diào)用、循環(huán)和條件語句等。如果try語句中的某行代碼產(chǎn)生了異常，該異常被拋出，則該語句之后的其他語句就不會再被執(zhí)行，程序會直接跳轉(zhuǎn)到與該異常匹配的catch語句塊中。catch語句塊中的異常參數(shù)提供了有關(guān)異常的詳細信息，例如異常類型、異常消息和堆棧跟蹤等內(nèi)容。

我們可以同時使用多個catch語句塊來處理不同類型的異常。在這種情況下，catch語句塊的順序就很重要，因為異常的處理會與catch語句塊的順序匹配。如果一個異?？梢云ヅ涠鄠€catch語句塊，則只有第一個匹配的語句塊會被執(zhí)行。

finally語句塊是可選的，不管是否發(fā)生異常，finally里的代碼都會被執(zhí)行。我們通常是在finally語句塊中執(zhí)行一些清理操作，比如關(guān)閉文件或釋放資源等。

3. 拋出異常

我們除了可以捕獲異常外，還可以在代碼中手動地通過throw語句來拋出異常。

if (x < 0) {
    throw new IllegalArgumentException("x不能為負數(shù)");
}

在上面的例子中，我們規(guī)定，如果x小于0，就手動拋出一個IllegalArgumentException異常，并將消息“x不能為負數(shù)”傳遞給異常。該異?？梢允侨魏蜹hrowable的子類，包括我們的自定義異常類。

4. 自定義異常

Java也允許我們創(chuàng)建自己的異常類。為了創(chuàng)建一個自定義的異常類，我們一般是繼承擴展Exception或RuntimeException類，如下所示。

public class MyException extends Exception {
    public MyException() {}
    public MyException(String message) {
        super(message);
    }
}

在上面的例子中，創(chuàng)建了一個自定義的異常類MyException，它擴展了Exception類。我們還提供了兩個構(gòu)造函數(shù)，一個不帶參數(shù)，另一個帶有一個字符串參數(shù)，用于設(shè)置異常消息。

5. 異常處理的最佳實踐

在Java中，異常處理是非常重要的，但也容易被濫用，下面是給大家總結(jié)的一些處理異常的最佳實踐。

5.1 不要捕獲過多的異常

捕獲過多的異常可能會使代碼難以理解和維護，我們通常是只捕獲必要的異常，并在可能的情況下將它們向上拋出，讓更高層次的代碼來處理它們。

5.2 不要忽略異常

忽略異?？赡軙钩绦蛟诤罄m(xù)的步驟中出現(xiàn)錯誤，進而導(dǎo)致數(shù)據(jù)出現(xiàn)損壞或其他不良后果。我們一般是在catch語句塊中處理異常，并使用日志來記錄異常信息，以便更好地了解問題。

5.3 不要在finally塊中返回值

在finally語句塊中返回值可能會導(dǎo)致不可預(yù)測的行為。如果一個方法在try語句塊中返回了一個值，在finally語句塊中又返回了另一個值，這可能會導(dǎo)致錯誤的結(jié)果。我們在finally語句塊中只應(yīng)該執(zhí)行清理操作，不應(yīng)該返回值。

5.4 將異常轉(zhuǎn)換

在某些情況下，我們可能需要將一個異常轉(zhuǎn)換為另一個異常。例如，我們想編寫一個庫，并且我們希望隱藏該庫的某些內(nèi)部實現(xiàn)細節(jié)，此時可以將一個異常轉(zhuǎn)換為另一個更通用的異常類型，以便客戶端代碼可以更容易地處理它。比如在下面的這個案例中，就用MyLibraryException替換了IOException。

public class MyLibrary {
    public void doSomething() throws MyLibraryException {
        try {
            // 執(zhí)行一些操作
        } catch (IOException e) {
            //拋出一個更通用的異常，用MyLibraryException替換IOException
            throw new MyLibraryException("發(fā)生了錯誤", e);
        }
    }
}
//自定義一個更通用的異常
public class MyLibraryException extends Exception {
    public MyLibraryException() {}
    public MyLibraryException(String message) {
        super(message);
    }
    public MyLibraryException(String message, Throwable cause) {
        super(message, cause);
    }
}

在上面的例子中，創(chuàng)建了一個自定義的異常類MyLibraryException，它擴展了Exception類。在MyLibrary類中，如果發(fā)生了IOException，我們就將其轉(zhuǎn)換為MyLibraryException，并將原始異常作為原因傳遞。

5.5 不要在構(gòu)造函數(shù)中拋出異常

在Java中，如果我們在構(gòu)造函數(shù)中拋出異常，則對象可能就無法完全初始化了，這可能會導(dǎo)致在后續(xù)的步驟中出現(xiàn)錯誤。所以我們最好避免在構(gòu)造函數(shù)中拋出異常，并使用工廠方法或靜態(tài)工廠方法來創(chuàng)建對象。

public class MyClass {
    private int x;
    private int y;
    public MyClass(int x, int y) {
        this.x = x;
        if (y < 0) {
            throw new IllegalArgumentException("y不能為負數(shù)");
        }
        this.y = y;
    }
    public static MyClass create(int x, int y) {
        if (y < 0) {
            throw new IllegalArgumentException("y不能為負數(shù)");
        }
        return new MyClass(x, y);
    }
}

在上面的例子中，使用了一個create工廠方法來創(chuàng)建MyClass對象。如果y為負數(shù)，則在創(chuàng)建對象之前會拋出一個IllegalArgumentException異常。

6. 異常處理時的常見問題

我們在進行異常處理時，也有一些常見的問題需要注意。

6.1 不要捕獲Throwable

Throwable是所有異常的超類，包括Error和Exception。開發(fā)時我們不能捕獲Throwable，因為它可能會捕獲到一些嚴(yán)重的錯誤，如OutOfMemoryError，這些錯誤是無法通過代碼處理的。所以在開發(fā)時，我們應(yīng)該去捕獲某個具體的異常類型。

6.2 不要在finally中拋出異常

如果我們在finally語句塊中拋出異常，有可能會導(dǎo)致之前拋出的異常被覆蓋，這可能會導(dǎo)致其他的一些錯誤。所以我們在finally語句塊中，一般只是進行清理操作，而不是拋出異常。

6.3 不要忽略InterruptedException

InterruptedException是一個非常特殊的異常，它通常表示線程被中斷。如果我們要在執(zhí)行長時間操作的線程上捕獲InterruptedException，應(yīng)該盡快停止線程并退出。如果繼續(xù)執(zhí)行，可能會導(dǎo)致一些無法預(yù)料的行為。

6.4 不要使用異常來控制流程

在某些情況下，我們可能會使用異常機制來控制程序的流程，但這并不是一種好的實踐。這會使代碼難以理解，還可能會導(dǎo)致性能問題。例如，下面的代碼中就使用了異常機制來控制循環(huán)的流程：

try {
    while (true) {
        // 一些操作
        if (someCondition) {
            throw new RuntimeException("循環(huán)已經(jīng)完成");
        }
    }
} catch (RuntimeException e) {
    // 處理異常
}

這種做法雖然在語法上是可行的，但如果我們想結(jié)束while循環(huán)，更好的辦法是使用一個標(biāo)志位來控制循環(huán)的流程，而不是使用異常機制。

boolean done = false;
while (!done) {
    // 一些操作
    if (someCondition) {
        done = true;
    }
}

6.5 不要忽略異常

我們在編寫代碼時，有可能會忽略掉異常，但這會導(dǎo)致代碼無法處理一些錯誤情況。在捕獲異常時，我們應(yīng)該始終記錄異?；虼蛴‘惓６褩８?，以便更好地弄清楚產(chǎn)生錯誤的原因。

try {
    // 一些操作
} catch (Exception e) {
    logger.error("發(fā)生了錯誤", e);
}

在上面的例子中，使用了日志記錄器來記錄異常，并將異常堆棧跟蹤作為額外信息傳遞。

6.6 不要在循環(huán)中捕獲異常

如果我們在循環(huán)內(nèi)部捕獲異常可能會導(dǎo)致性能問題，并讓代碼更難理解。通常是將循環(huán)體封裝在一個try語句塊中，而不是在循環(huán)內(nèi)部捕獲異常。

try {
    for (int i = 0; i < list.size(); i++) {
        // 一些操作
    }
} catch (Exception e) {
    logger.error("發(fā)生了錯誤", e);
}

在上面的例子中，我們使用try語句塊來包裝循環(huán)體，而不是在循環(huán)內(nèi)部捕獲異常。

四. 結(jié)語

Java的異常處理機制是一種強大的工具，可以幫助我們處理各種異常情況。所以熟練掌握異常處理機制的基礎(chǔ)知識和最佳實踐，可以幫助我們編寫更健壯、可靠的代碼。

我們在編寫代碼時，應(yīng)該提前考慮到各種異常情況，并在可能的情況下使用異常機制來處理這些情況。要注意，異常處理機制應(yīng)該是代碼的一部分，而不是控制流程的一部分。同時，還應(yīng)該注意避免常見的異常處理問題，例如捕獲Throwable、在finally塊中拋出異常、忽略InterruptedException等。并且我們還要注意保持代碼的簡潔性和可讀性。

以上就是學(xué)習(xí)Java之Java中的異常處理機制詳解的詳細內(nèi)容，更多關(guān)于Java異常處理機制的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論