一、Java異常架構與異常關鍵字

Java異常簡介

Java 異常是 Java 提供的一種識別及響應錯誤的一致性機制。

Java 異常機制可以使程序中異常處理代碼和正常業(yè)務代碼分離，保證程序代碼更加優(yōu)雅，并提高程序健壯性。

在有效使用異常的情況下，異常能清晰的回答 what，where，why 這3個問題：

• 異常類型回答了 “什么” 被拋出
• 異常堆棧跟蹤回答了 “在哪” 拋出
• 異常信息回答了 “為什么” 會拋出

Java異常架構

1、Throwable

Throwable 是 Java 語言中所有錯誤與異常的超類。

Throwable 包含兩個子類：Error（錯誤）和 Exception（異常），它們通常用于指示發(fā)生了異常情況。

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

2、Error（錯誤）

定義：Error 類及其子類。程序中無法處理的錯誤，表示運行應用程序中出現(xiàn)了嚴重的錯誤。

特點：此類錯誤一般表示代碼運行時 JVM 出現(xiàn)問題。

通常有 Virtual MachineError（虛擬機運行錯誤）、NoClassDefFoundError（類定義錯誤）等。

比如 OutOfMemoryError：內(nèi)存不足錯誤；StackOverflowError：棧溢出錯誤。此類錯誤發(fā)生時，JVM 將終止線程。

這些錯誤是不受檢異常，非代碼性錯誤。因此，當此類錯誤發(fā)生時，應用程序不應該去處理此類錯誤。

按照 Java 慣例，我們是不應該實現(xiàn)任何新的 Error 子類的！

3、Exception（異常）

程序本身可以捕獲并且可以處理的異常。Exception 這種異常又分為兩類：運行時異常和編譯時異常。

運行時異常

定義：RuntimeException 類及其子類，表示 JVM 在運行期間可能出現(xiàn)的異常。

特點：Java 編譯器不會檢查它。也就是說，當程序中可能出現(xiàn)這類異常時，倘若既 “沒有通過throws聲明拋出它”，也 “沒有用try-catch語句捕獲它”，還是會編譯通過。

比如 NullPointerException 空指針異常、ArrayIndexOutBoundException 數(shù)組下標越界異常、ClassCastException 類型轉換異常、ArithmeticExecption 算術異常。

此類異常屬于不受檢異常，一般是由程序邏輯錯誤引起的，在程序中可以選擇捕獲處理，也可以不處理。

雖然 Java 編譯器不會檢查運行時異常，但是我們也可以通過 throws 進行聲明拋出，也可以通過 try-catch 對它進行捕獲處理。

如果產(chǎn)生運行時異常，則需要通過修改代碼來進行避免。例如，若會發(fā)生除數(shù)為零的情況，則需要通過代碼避免該情況的發(fā)生！

RuntimeException 異常會由 Java 虛擬機自動拋出并自動捕獲，就算我們沒寫異常捕獲語句運行時也會拋出錯誤！

此類異常的出現(xiàn)絕大數(shù)情況是代碼本身有問題，應該從邏輯上去解決并改進代碼。

編譯時異常

定義：Exception 中除 RuntimeException 及其子類之外的異常。

特點：Java 編譯器會檢查它。如果程序中出現(xiàn)此類異常，比如 ClassNotFoundException（沒有找到指定的類異常），IOException（IO流異常），要么通過 throws 進行聲明拋出，要么通過 try-catch 進行捕獲處理，否則不能通過編譯。

在程序中，通常不會自定義該類異常，而是直接使用系統(tǒng)提供的異常類。

該異常我們必須手動在代碼里添加捕獲語句來處理該異常。

4、受檢異常與非受檢異常

Java 的所有異?？梢苑譃槭軝z異常（checked exception）和非受檢異常（uncheckedexception）。

受檢異常

編譯器要求必須處理的異常。

正確的程序在運行過程中，經(jīng)常容易出現(xiàn)的、符合預期的異常情況。一旦發(fā)生此類異常，就必須采用某種方式進行處理。

除 RuntimeException 及其子類外，其他的 Exception 異常都屬于受檢異常，編譯器會檢查此類異常。

也就是說當編譯器檢查到應用中的某處可能會此類異常時，將會提示你處理本異常，

要么使用try-catch捕獲，要么使用方法簽名中用 throws 關鍵字拋出，否則編譯不通過。

非受檢異常

編譯器不會進行檢查并且不要求必須處理的異常。

也就說當程序中出現(xiàn)此類異常時，即使我們沒有 try-catch 捕獲它，也沒有使用throws拋出該異常，編譯也會正常通過。

該類異常包括運行時異常（RuntimeException 及其子類）和錯誤（Error）。

Java異常關鍵字

• try：用于監(jiān)聽。

將要被監(jiān)聽的代碼（可能拋出異常的代碼）放在 try 語句塊之內(nèi)，當 try 語句塊內(nèi)發(fā)生異常時，異常就被拋出。

• catch：用于捕獲異常。

catch 用來捕獲 try 語句塊中發(fā)生的異常。

• finally：finally 語句塊總是會被執(zhí)行。

它主要用于回收在 try 塊里打開的物力資源（如數(shù)據(jù)庫連接、網(wǎng)絡連接和磁盤文件）。

只有 finally 塊，執(zhí)行完成之后，才會回來執(zhí)行 try 或者 catch 塊中的 return 或者 throw 語句，

如果 finally 中使用了 return 或者 throw 等終止方法的語句，則就不會跳回執(zhí)行，直接停止。

• throw：用于拋出異常。
• throws：用在方法簽名中，用于聲明該方法可能拋出的異常。

二、Java異常處理

Java 通過面向對象的方法進行異常處理，一旦方法拋出異常，系統(tǒng)自動根據(jù)該異常對象尋找合適異常處理器（Exception Handler）來處理該異常，把各種不同的異常進行分類，并提供了良好的接口。

在 Java 中，每個異常都是一個對象，它是 Throwable 類或其子類的實例。

當一個方法出現(xiàn)異常后便拋出一個異常對象，該對象中包含有異常信息，調(diào)用這個對象的方法可以捕獲到這個異常并可以對其進行
處理。

Java 的異常處理是通過 5 個關鍵詞來實現(xiàn)的：try、catch、throw、throws 和 finally。

在Java應用中，異常的處理機制分為聲明異常，拋出異常和捕獲異常。

聲明異常

通常，應該捕獲那些知道如何處理的異常，將不知道如何處理的異常繼續(xù)傳遞下去。

傳遞異?？梢栽诜椒ê灻幨褂?throws 關鍵字聲明可能會拋出的異常。

注意：

• 非檢查異常（Error、RuntimeException 或它們的子類）不可使用 throws 關鍵字來聲明要拋出的異常。
• 一個方法出現(xiàn)編譯時異常，就需要 try-catch/ throws 處理，否則會導致編譯錯誤。
  

拋出異常

如果你覺得解決不了某些異常問題，且不需要調(diào)用者處理，那么你可以拋出異常。

throw 關鍵字作用是在方法內(nèi)部拋出一個 Throwable 類型的異常。

任何Java代碼都可以通過 throw 語句拋出異常。

捕獲異常

程序通常在運行之前不報錯，但是運行后可能會出現(xiàn)某些未知的錯誤，但是還不想直接拋出到上一級，

那么就需要通過 try…catch… 的形式進行異常捕獲，之后根據(jù)不同的異常情況來進行相應的處理。

如何選擇異常類型

可以根據(jù)下圖來選擇是捕獲異常，聲明異常還是拋出異常

常見異常處理方式

1、直接拋出異常

通常，應該捕獲那些知道如何處理的異常，將不知道如何處理的異常繼續(xù)傳遞下去。

傳遞異?？梢栽诜椒ê灻幨褂?throws 關鍵字聲明可能會拋出的異常。

public static void readFile(String filePath) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader(filePath));
    String res;

    while ( (res = reader.readLine()) != null ) {
        System.out.println(res);
    }
    reader.close();
}

2、封裝異常再拋出

有時我們會從 catch 中拋出一個異常，目的是為了改變異常的類型。多用于在多系統(tǒng)集成時，

當某個子系統(tǒng)故障，異常類型可能有多種，可以用統(tǒng)一的異常類型向外暴露，不需暴露太多內(nèi)部異常細節(jié)。

自定義一個異常 MyException

public class MyException extends Exception {

    public MyException() {
        super();
    }

    public MyException(String message) {
        super(message);
    }
}

使用自定義異常封裝異常

public static void readFile(String filePath) throws MyException {
    BufferedReader reader = null;
    String res;
    try {
        reader = new BufferedReader(new FileReader(filePath));
        while ( (res = reader.readLine()) != null ) {
            System.out.println(res);
        }
    } catch (IOException e) {
        MyException myException = new MyException("讀取文件失?。?);
        myException.initCause(e);
        throw myException;
    }

    try {
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3、捕獲異常

在一個 try-catch 語句塊中可以捕獲多個異常類型，并對不同類型的異常做出不同的處理。

public static void readFile(String filePath) {
    try {
        // do
    } catch (FileNotFoundException e) {
        // handle FileNotFoundException
    } catch (IOException e) {
        // handle IOException
    }
}

同一個 catch 也可以捕獲多種類型異常，用 | 隔開

public static void readFile(String filePath) {
    try {
        // do
    } catch (FileNotFoundException | UnknownHostException e) {
        // handle FileNotFoundException or UnknownHostException
    } catch (IOException e) {
        // handle IOException
    }
}

4、自定義異常

習慣上，定義一個異常類應包含兩個構造函數(shù)，一個無參構造函數(shù)和一個帶有詳細描述信息的構造函數(shù)，

Throwable 的 toString 方法會打印這些詳細信息，調(diào)試時很有用。

public class MyException extends Exception {

    public MyException() {
        super();
    }

    public MyException(String message) {
        super(message);
    }
}

5、try-catch-finally

當方法中發(fā)生異常，異常處之后的代碼不會再執(zhí)行，如果之前獲取了一些本地資源需要釋放，

則需要在方法正常結束時和 catch 語句中都調(diào)用釋放本地資源的代碼，顯得代碼比較繁瑣，

finally 語句可以解決這個問題。

public static void readFile(String filePath) throws MyException {
    BufferedReader reader = null;
    String res;
    try {
        reader = new BufferedReader(new FileReader(filePath));
        while ( (res = reader.readLine()) != null ) {
            System.out.println(res);
        }
    } catch (IOException e) {
        System.out.println("catch 代碼塊");
        MyException myException = new MyException("讀取文件失??！");
        myException.initCause(e);
        throw myException;
    } finally {
        System.out.println("finally 代碼塊");
        if (null != reader) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

調(diào)用該方法時，讀取文件時若發(fā)生異常，代碼會進入 catch 代碼塊，之后進入 finally 代碼塊；

若讀取文件時未發(fā)生異常，則會跳過 catch 代碼塊直接進入 finally 代碼塊。

所以無論代碼中是否發(fā)生異常，fianlly 中的代碼都會執(zhí)行。

若 catch 代碼塊中包含 return 語句，finally 中的代碼還會執(zhí)行嗎？將以上代碼中的 catch 子句修改如下：

catch (IOException e) {
    System.out.println("catch 代碼塊");
    return ;
} 

調(diào)用 readFile 方法，觀察當 catch 子句中調(diào)用 return 語句時，finally 子句是否執(zhí)行

catch 代碼塊
finally 代碼塊

可見，即使 catch 中包含了 return 語句，finally 子句依然會執(zhí)行。

若 finally 中也包含 return 語句，finally 中的 return 會覆蓋前面的 return。

6、try-with-resource

上面例子中，finally 中的 close 方法也可能拋出 IOException，從而覆蓋了原始異常。

JAVA 7 提供了更優(yōu)雅的方式來實現(xiàn)資源的自動釋放，自動釋放的資源需要是實現(xiàn)了 AutoCloseable 接口的類。

public static void tryWithResourceTest() {
    try {
        Scanner scanner = new Scanner(new FileInputStream("d:/"),"UTF-8");
    } catch (IOException e) {
        // handle IOException
    }
}

try 代碼塊退出時，會自動調(diào)用 scanner.close 方法，和把 scanner.close 方法放在 finally 代碼塊中不同的是，

若 scanner.close 拋出異常，則會被抑制，拋出的仍然為原始異常。

被抑制的異常會由 addSusppressed 方法添加到原來的異常，如果想要獲取被抑制的異常列表，

可以調(diào)用 getSuppressed 方法來獲取。

三、Java異常常見面試題

1、Error 和 Exception 區(qū)別是什么？

Error 類型的錯誤通常為虛擬機相關錯誤，如系統(tǒng)崩潰，內(nèi)存不足，堆棧溢出等，

編譯器不會對這類錯誤進行檢測，JAVA 應用程序也不應對這類錯誤進行捕獲，

一旦這類錯誤發(fā)生，通常應用程序會被終止，僅靠應用程序本身無法恢復；

Exception 類的錯誤是可以在應用程序中進行捕獲并處理的，通常遇到這種錯誤，

應對其進行處理，使應用程序可以繼續(xù)正常運行。

2、運行時異常和一般異常(受檢異常)區(qū)別是什么？

運行時異常包括 RuntimeException 類及其子類，表示 JVM 在運行期間可能出現(xiàn)的異常。

Java 編譯器不會檢查運行時異常。受檢異常是 Exception 中除 RuntimeException 及其子類之外的異常。

Java 編譯器會檢查受檢異常。

RuntimeException異常和受檢異常之間的區(qū)別：是否強制要求調(diào)用者必須處理此異常，

如果強制要求調(diào)用者必須進行處理，那么就使用受檢異常，否則就選擇非受檢異常（RuntimeException）。

一般來講，如果沒有特殊的要求，我們建議使用 RuntimeException 異常。

3、JVM 是如何處理異常的？

在一個方法中如果發(fā)生異常，這個方法會創(chuàng)建一個異常對象，并轉交給 JVM，

該異常對象包含異常名稱，異常描述以及異常發(fā)生時應用程序的狀態(tài)。

創(chuàng)建異常對象并轉交給 JVM 的過程稱為拋出異常。

可能有一系列的方法調(diào)用，最終才進入拋出異常的方法，這一系列方法調(diào)用的有序列表叫做調(diào)用棧。

JVM 會順著調(diào)用棧去查找看是否有可以處理異常的代碼，如果有，則調(diào)用異常處理代碼。

當 JVM 發(fā)現(xiàn)可以處理異常的代碼時，會把發(fā)生的異常傳遞給它。

如果 JVM 沒有找到可以處理該異常的代碼塊，JVM 就會將該異常轉交給默認的異常處理器，

默認異常處理器為 JVM 的一部分，默認異常處理器會打印出異常信息并終止應用程序。

4、throw 和 throws 的區(qū)別是什么？

Java 中的異常處理除了包括捕獲異常和處理異常之外，還包括聲明異常和拋出異常，

可以通過 throws 關鍵字在方法上聲明該方法要拋出的異常，或者在方法內(nèi)部通過 throw 拋出異常對象。

throws 關鍵字和 throw 關鍵字在使用上的幾點區(qū)別如下：

• throw 關鍵字用在方法內(nèi)部，只能用于拋出一種異常，用來拋出方法或代碼塊中的異常，

受查異常和非受查異常都可以被拋出；

• throws 關鍵字用在方法聲明上，可以拋出多個異常，用來標識該方法可能拋出的異常列表。

一個方法用 throws 標識了可能拋出的異常列表，調(diào)用該方法的方法中必須包含可處理異常的代碼，

否則也要在方法簽名中用 throws 關鍵字聲明相應的異常。

5、final、finally、finalize 有什么區(qū)別？

• final 可以修飾類、變量、方法，修飾類表示該類不能被繼承、修飾方法表示該方法不能被重寫、修飾變量

表示該變量是一個常量不能被重新賦值。

• finally一般作用在 try-catch 代碼塊中，在處理異常的時候，通常我們將一定要執(zhí)行的代碼方法 finally 代碼

塊中，表示不管是否出現(xiàn)異常，該代碼塊都會執(zhí)行，一般用來存放一些關閉資源的代碼。

• finalize 是一個方法，屬于 Object 類的一個方法，而 Object 類是所有類的父類，Java 中允許使用 finalize()

方法在垃圾收集器將對象從內(nèi)存中清除出去之前做必要的清理工作。

6、NoClassDefFoundError 和 ClassNotFoundException 區(qū)別？

NoClassDefFoundError 是一個 Error 類型的異常，是由 JVM 引起的，不應該嘗試捕獲這個異常。

引起該異常的原因是 JVM 或 ClassLoader 嘗試加載某類時在內(nèi)存中找不到該類的定義，

該動作發(fā)生在運行期間，即編譯時該類存在，但是在運行時卻找不到了，可能是變異后被刪除了等原因導致；

ClassNotFoundException 是一個受查異常，需要顯式地使用 try-catch 對其進行捕獲和處理，

或在方法簽名中用 throws 關鍵字進行聲明。

當使用 Class.forName，ClassLoader.loadClass 或 ClassLoader.findSystemClass 動態(tài)加載類到內(nèi)存的時候，

通過傳入的類路徑參數(shù)沒有找到該類，就會拋出該異常；

另一種拋出該異常的可能原因是某個類已經(jīng)由一個類加載器加載至內(nèi)存中，另一個加載器又嘗試去加載它。

7、try-catch-finally 中哪個部分可以省略？

catch 可以省略。

原因

更為嚴格的說法其實是：try 只適合處理運行時異常，try+catch 適合處理運行時異常+普通異常。

也就是說，如果你只用try去處理普通異常卻不加以catch處理，編譯是通不過的，

因為編譯器硬性規(guī)定，普通異常如果選擇捕獲，則必須用 catch 顯示聲明以便進一步處理。

而運行時異常在編譯時沒有如此規(guī)定，所以 catch 可以省略，你加上 catch 編譯器也覺得無可厚非。

理論上，編譯器看任何代碼都不順眼，都覺得可能有潛在的問題，所以你即使對所有代碼加上try，

代碼在運行期時也只不過是在正常運行的基礎上加一層皮。

但是你一旦對一段代碼加上 try，就等于顯示地承諾編譯器，對這段代碼可能拋出的異常進行捕獲，而非向上拋出處理。

如果是普通異常，編譯器要求必須用 catch 捕獲以便進一步處理；

如果運行時異常，捕獲然后丟棄并且+ finally 掃尾處理，或者加上 catch 捕獲以便進一步處理。

至于加上 finally，則是在不管有沒捕獲異常，都要進行的 “掃尾” 處理。

8、try-catch-finally 中，如果 catch 中 return 了，finally 還會執(zhí)行嗎？

會執(zhí)行，在 return 前執(zhí)行。

注意：在 finally 中改變返回值的做法是不好的，因為如果存在 finally 代碼塊，try中的 return 語句不會立馬返回調(diào)用者，

而是記錄下返回值待 finally 代碼塊執(zhí)行完畢之后再向調(diào)用者返回其值，然后如果在 finally 中修改了返回值，就會返回修改后的值。

顯然，在 finally 中返回或者修改返回值會對程序造成很大的困擾，C# 中直接用編譯錯誤的方式來阻止程序員干這種事情，

Java 中也可以通過提升編譯器的語法檢查級別來產(chǎn)生警告或錯誤。

例子1

public static int getInt() {
    int a = 10;
    try {
        System.out.println(a / 0);
        a = 20;
    } catch (ArithmeticException e) {
        a = 30;
        // 程序執(zhí)行到這里時，不是 return a，而是 return 30，這個返回路徑已經(jīng)形成
        // 但是后面還有 finally，所以繼續(xù)執(zhí)行 finally 內(nèi)容，a = 40
        // 再次回到這里，繼續(xù) return 30，形成返回路徑后，這里的 a 就不是變量了，
        // 而是常量 30，所以結果為 30
        return a;
    } finally {
        a = 40;
    }
    return a;
}

執(zhí)行結果：30

例子2

public static int getInt() {
    int a = 10;
    try {
        System.out.println(a / 0);
        a = 20;
    } catch (ArithmeticException e) {
        a = 30;
        return a;
    } finally {
        a = 40;
        // 如果 finally 中 return，這樣就重新又形成了一條返回路徑，
        // 由于只能通過 1 個 return 返回，所以這里直接返回 40
        return a;
    }
}

執(zhí)行結果：40

9、類 ExampleA 繼承 Exception，類 ExampleB 繼承ExampleA。

有如下代碼片斷：

try {
    throw new ExampleB("B");
} catch (ExampleA e) {
    System.out.println("ExampleA");
} catch (Exception e) {
    System.out.println("Exception");
}

請問執(zhí)行結果是什么？

輸出：ExampleA

說明：根據(jù)里氏代換原則（能使用父類型的地方一定能使用子類型），

抓取 ExampleA 類型異常的 catch 塊能夠抓住 try 塊中拋出的 ExampleB 類型的異常。

10、說出下面代碼的運行結果

class AnnoyanceException extends Exception {
}

class SneezeException extends AnnoyanceException {
}

public class Test04 {
    public static void main(String[] args) throws Exception {
        try {
            try {
                throw new SneezeException();
            } catch (AnnoyanceException a) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        } catch (SneezeException s) {
            System.out.println("Caught Sneeze");
            return;
        } finally {
            System.out.println("Hello World");
        }
    }
}

結果：

Caught Annoyance
Caught Sneeze
Hello World

11、常見的 RuntimeException 有哪些？

• ClassCastException（類轉換異常）
• IndexOutOfBoundsException（數(shù)組越界）
• NullPointerException（空指針）
• ArrayStoreException（數(shù)據(jù)存儲異常，操作數(shù)組時類型不一致）
• 還有IO操作的 BufferOverflowException 異常
  

12、Java常見異常有哪些

• java.lang.IllegalAccessError：違法訪問錯誤。當一個應用試圖訪問、修改某個類的域（Field）或者調(diào)用其方法，但是又違反域或方法的可見性聲明，則拋出該異常。
• java.lang.InstantiationError：實例化錯誤。當一個應用試圖通過 Java 的 new 操作符構造一個抽象類或者接口時拋出該異常。
• java.lang.OutOfMemoryError：內(nèi)存不足錯誤。當可用內(nèi)存不足以讓 Java 虛擬機分配給一個對象時拋出該錯誤。
• java.lang.StackOverflowError：堆棧溢出錯誤。當一個應用遞歸調(diào)用的層次太深而導致堆棧溢出或者陷入死循環(huán)時拋出該錯誤。
• java.lang.ClassCastException：類造型異常。假設有類 A 和 B（A 不是 B 的父類或子類），O 是 A 的實例，那么當強制將 O 構造為類B的實例時拋出該異常。該異常經(jīng)常被稱為強制類型轉換異常。
• java.lang.ClassNotFoundException：找不到類異常。當應用試圖根據(jù)字符串形式的類名構造類，而在遍歷 CLASSPAH 之后找不到對應名稱的 class 文件時，拋出該異常。
• java.lang.ArithmeticException：算術條件異常。譬如：整數(shù)除零等。
• java.lang.ArrayIndexOutOfBoundsException：數(shù)組索引越界異常。當對數(shù)組的索引值為負數(shù)或大于等于數(shù)組大小時拋出。
• java.lang.IndexOutOfBoundsException：索引越界異常。當訪問某個序列的索引值小于0或大于等于序列大小時，拋出該異常。
• java.lang.InstantiationException：實例化異常。當試圖通過 newInstance() 方法創(chuàng)建某個類的實例，而該類是一個抽象類或接口時，拋出該異常。
• java.lang.NoSuchFieldException：屬性不存在異常。當訪問某個類的不存在的屬性時拋出該異常。
• java.lang.NoSuchMethodException：方法不存在異常。當訪問某個類的不存在的方法時拋出該異常。
• java.lang.NullPointerException：空指針異常。當應用試圖在要求使用對象的地方使用了 null 時，拋出該異常。譬如：調(diào)用 null 對象的實例方法、訪問 null 對象的屬性、計算 null 對象的長度、使用 throw 語句拋出 null 等等。
• java.lang.NumberFormatException：數(shù)字格式異常。當試圖將一個 String 轉換為指定的數(shù)字類型，而該字符串確不滿足數(shù)字類型要求的格式時，拋出該異常。
• java.lang.StringIndexOutOfBoundsException：字符串索引越界異常。當使用索引值訪問某個字符串中的字符，而該索引值小于0或大于等于序列大小時，拋出該異常。

13、Java 異常中 Throwable、Error、Exception、RuntimeException 的區(qū)別

• Throwable 類是 Java 語言中所有錯誤或異常的超類。它的兩個子類是 Error 和 Exception；
• Error 是 Throwable 的子類，用于指示合理的應用程序不應該試圖捕獲的嚴重問題，如內(nèi)存溢出、虛擬機錯誤、棧溢出等。

這類錯誤一般與硬件有關，與程序本身無關，通常由系統(tǒng)進行處理，程序本身無法捕獲和處理。

OutOfMemoryError 內(nèi)存溢出

java.lang.StackOverflowError 堆棧溢出錯誤，當一個應用遞歸調(diào)用的層次太深而導致堆棧溢出時拋出該錯誤

• Exception 類及其子類是 Throwable 的一種形式，合理的應用程序想要捕獲的條件，有些異常在編寫程序時無法預料的，

如中斷異常、非法存取異常等。為了保證程序的健壯性，Java 要求必須對這些可能出現(xiàn)的異常進行捕獲，并對其進行處理

• RuntimeException 類是 Exception 類的子類（可能在Java虛擬機正常運行期間拋出的異常的超類）；
• IOExeption類是Exception類的子類。

四、Java異常處理最佳實踐

在 Java 中處理異常并不是一個簡單的事情。不僅僅初學者很難理解，即使一些有經(jīng)驗的開發(fā)者，

也需要花費很多時間來思考如何處理異常，包括需要處理哪些異常，怎樣處理等等。

這也是絕大多數(shù)開發(fā)團隊都會制定一些規(guī)則來規(guī)范進行異常處理的原因。而團隊之間的這些規(guī)范往往是截然不同的。

本文給出幾個被很多團隊使用的異常處理最佳實踐。

1、在 finally 塊中清理資源或者使用 try-with-resource 語句

當使用類似 InputStream 這種需要使用后關閉的資源時，一個常見的錯誤就是在 try 塊的最后關閉資源。

public static void readFile(String filePath) {
    BufferedReader reader = null;
    String res;
    try {
        reader = new BufferedReader(new FileReader(filePath));
        while ( (res = reader.readLine()) != null ) {
            System.out.println(res);
        }
        reader.close(); // 錯誤！
    } catch (IOException e) {
        e.printStackTrace();
    }
}

問題就是，只有沒有異常拋出的時候，這段代碼才可以正常工作。try 代碼塊內(nèi)代碼會正常執(zhí)行，

并且資源可以正常關閉。但是，使用 try 代碼塊是有原因的，一般調(diào)用一個或多個可能拋出異常的方法，

而且，你自己也可能會拋出一個異常，這意味著代碼可能不會執(zhí)行到 try 代碼塊的最后部分。

結果就是，并沒有關閉資源。所以，應該把清理工作的代碼放到 finally 里去，或者使用 try-with-resource 特性。

(1）使用 finally 代碼塊

與前面幾行 try 代碼塊不同，finally 代碼塊總是會被執(zhí)行。

不管 try 代碼塊成功執(zhí)行之后還是在 catch 代碼塊中處理完異常后都會執(zhí)行。

因此，可以確保這里清理了所有打開的資源。

public static void readFile(String filePath) {
    BufferedReader reader = null;
    String res;
    try {
        reader = new BufferedReader(new FileReader(filePath));
        while ( (res = reader.readLine()) != null ) {
            System.out.println(res);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (null != reader) { // 正確
            try {   
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

(2）Java 7 的 try-with-resource 語法

如果你的資源實現(xiàn)了 AutoCloseable 接口，你可以使用這個語法。大多數(shù)的 Java 標準資源都繼承了這個接口。

當你在 try 子句中打開資源，資源會在 try 代碼塊執(zhí)行后或異常處理后自動關閉。

public static void readFile(String filePath) {
    String res;
    try {
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        while ( (res = reader.readLine()) != null ) {
            System.out.println(res);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

2、優(yōu)先明確的異常

你拋出的異常越明確越好，永遠記住，你的同事或者幾個月之后的你，將會調(diào)用你的方法并且處理異常。

因此需要保證提供給他們盡可能多的信息。這樣你的 API 更容易被理解。

你的方法的調(diào)用者能夠更好的處理異常并且避免額外的檢查。因此，總是嘗試尋找最適合你的異常事件的類。

例如，拋出一個 NumberFormatException ，來替換一個 IllegalArgumentException 。避免拋出一個不明確的異常。

public void doNotDoThis() throws Exception {
    
}
public void doThis() throws NumberFormatException {
    
}

3、對異常進行文檔說明

當在方法上聲明拋出異常時，也需要進行文檔說明。目的是為了給調(diào)用者提供盡可能多的信息，

從而可以更好地避免或處理異常。在 Javadoc 添加 @throws 聲明，并且描述拋出異常的場景。

4、使用描述性消息拋出異常

在拋出異常時，需要盡可能精確地描述問題和相關信息，這樣無論是打印到日志中還是在監(jiān)控工具中，

都能夠更容易被人閱讀，從而可以更好地定位具體錯誤信息、錯誤的嚴重程度等。

但這里并不是說要對錯誤信息長篇大論，因為本來 Exception 的類名就能夠反映錯誤的原因，因此只需要用一到兩句話描述即可。

如果拋出一個特定的異常，它的類名很可能已經(jīng)描述了這種錯誤。所以你不需要提供很多額外的信息。

一個很好的例子是 NumberFormatException 。當你以錯誤的格式提供 String 時，它將被 java.lang.Long 類的構造函數(shù)拋出。

try {
    new Long("xxx");
} catch (NumberFormatException e) {
    e.printStackTrace();
}

拋出

java.lang.NumberFormatException: For input string: "xxx"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:589)
	at java.lang.Long.<init>(Long.java:965)

5、優(yōu)先捕獲最具體的異常

大多數(shù) IDE 都可以幫助你實現(xiàn)這個最佳實踐。當你嘗試首先捕獲較不具體的異常時，它們會報告無法訪問的代碼塊。

但問題在于，只有匹配異常的第一個 catch 塊會被執(zhí)行。

因此，如果首先捕獲 IllegalArgumentException，則永遠不會到達應該處理更具體的 NumberFormatException 的 catch 塊，

因為它是 IllegalArgumentException 的子類。

總是優(yōu)先捕獲最具體的異常類，并將不太具體的 catch 塊添加到列表的末尾。

public static void catchMostSpecificExceptionFirst() {
    try {
        // do
    } catch (NumberFormatException e) {
        // handle NumberFormatException
    } catch (IllegalArgumentException e) {
        // handle IllegalArgumentException
    }
}

6、不要捕獲 Throwable 類

Throwable 是所有異常和錯誤的超類。你可以在 catch 子句中使用它，但是你永遠不應該這樣做！

如果在 catch 子句中使用 Throwable ，它不僅會捕獲所有異常，也將捕獲所有的錯誤。

JVM 拋出錯誤，指出不應該由應用程序處理的嚴重問題。

典型的例子是 OutOfMemoryError 或者 StackOverflowError 。

兩者都是由應用程序控制之外的情況引起的，無法處理。所以，最好不要捕獲 Throwable ，

除非你確定自己處于一種特殊的情況下能夠處理錯誤。

7、不要忽略異常

很多時候，開發(fā)者很有自信不會拋出異常，因此寫了一個catch塊，但是沒有做任何處理或者記錄日志。

public void doNotIgnoreExceptions() { 
    try{ 
        // do 
    } catch (NumberFormatException e){ 
        // this will neverhappen
    }
}

但現(xiàn)實是經(jīng)常會出現(xiàn)無法預料的異常，或者無法確定這里的代碼未來是不是會改動（刪除了阻止異常拋出的代碼），

而此時由于異常被捕獲，使得無法拿到足夠的錯誤信息來定位問題。合理的做法是至少要記錄異常的信息。

public void logAnException() { 
    try{ 
        // do 
    } catch (NumberFormatException e){ 
        log.error("This should never happen: "+ e)
    }
}

8、不要記錄并拋出異常

這可能是最常被忽略的最佳實踐?？梢园l(fā)現(xiàn)很多代碼甚至類庫中都會有捕獲異常、記錄日志并再次拋出的邏輯。

try {
    new Long("xxx");
} catch (NumberFormatException e) {
    log.error(e);
    throw e;
}

這個處理邏輯看著是合理的。但這經(jīng)常會給同一個異常輸出多條日志。

多余的日志也沒有附加更有用的信息。如果想要提供更加有用的信息，那么可以將異常包裝為自定義異常。

public void wrapException(String input) throws MyException {
    try { 
        // do 
    } catch(NumberFormatException e) { 
        throw new MyException("A message that describesthe error.", e);
    }
}

因此，僅僅當想要處理異常時才去捕獲，否則只需要在方法簽名中聲明讓調(diào)用者去處理。

9、包裝異常時不要拋棄原始的異常

捕獲標準異常并包裝為自定義異常是一個很常見的做法。這樣可以添加更為具體的異常信息并能夠做針對的異常處理。

在你這樣做時，請確保將原始異常設置為原因（注：參考下方代碼 NumberFormatException e 中的原始異常 e ）。

Exception 類提供了特殊的構造函數(shù)方法，它接受一個 Throwable 作為參數(shù)。

否則，你將會丟失堆棧跟蹤和原始異常的消息，這將會使分析導致異常的異常事件變得困難。

public void wrapException(String input) throws MyException {
    try { 
        // do 
    } catch(NumberFormatException e) { 
        throw new MyException("A message that describesthe error.", e);
        // 等價于 
        // MyException myException = new MyException("A message that describesthe error.");
        // myException.initCause(e);
        // throw myException;
    }
}

10、不要使用異常控制程序的流程

不應該使用異?？刂茟玫膱?zhí)行流程，例如，本應該使用if語句進行條件判斷的情況下，

你卻使用異常處理，這是非常不好的習慣，會嚴重影響應用的性能。

11、使用標準異常

如果使用內(nèi)建的異常可以解決問題，就不要定義自己的異常。

Java API 提供了上百種針對不同情況的異常類型，在開發(fā)中首先盡可能使用 Java API 提供的異常，

如果標準的異常不能滿足你的要求，這時候創(chuàng)建自己的定制異常。盡可能得使用標準異常有利于新加入的開發(fā)者看懂項目代碼。

12、異常會影響性能

異常處理的性能成本非常高，每個 Java 程序員在開發(fā)時都應牢記這句話。

創(chuàng)建一個異常非常慢，拋出一個異常又會消耗1~5ms，

當一個異常在應用的多個層級之間傳遞時，會拖累整個應用的性能。

• 僅在異常情況下使用異常；
• 在可恢復的異常情況下使用異常；

盡管使用異常有利于 Java 開發(fā)，但是在應用中最好不要捕獲太多的調(diào)用棧，

因為在很多情況下都不需要打印調(diào)用棧就知道哪里出錯了。

因此，異常消息應該提供恰到好處的信息。

13、總結

綜上所述，當你拋出或捕獲異常的時候，有很多不同的情況需要考慮，

而且大部分事情都是為了改善代碼的可讀性或者 API 的可用性。

異常不僅僅是一個錯誤控制機制，也是一個通信媒介。

因此，為了和同事更好的合作，一個團隊必須要制定出一個最佳實踐和規(guī)則，

只有這樣，團隊成員才能理解這些通用概念，同時在工作中使用它。

五、異常處理-阿里巴巴Java開發(fā)手冊

到此這篇關于超詳細講解Java異常的文章就介紹到這了,更多相關Java異常內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論