一、Java異常架構(gòu)與異常關(guān)鍵字
Java異常簡(jiǎn)介
Java 異常是 Java 提供的一種識(shí)別及響應(yīng)錯(cuò)誤的一致性機(jī)制。
Java 異常機(jī)制可以使程序中異常處理代碼和正常業(yè)務(wù)代碼分離，保證程序代碼更加優(yōu)雅，并提高程序健壯性。
在有效使用異常的情況下，異常能清晰的回答 what，where，why 這3個(gè)問(wèn)題：
- 異常類(lèi)型回答了 “什么” 被拋出
- 異常堆棧跟蹤回答了 “在哪” 拋出
- 異常信息回答了 “為什么” 會(huì)拋出
Java異常架構(gòu)
1、Throwable
Throwable 是 Java 語(yǔ)言中所有錯(cuò)誤與異常的超類(lèi)。
Throwable 包含兩個(gè)子類(lèi)：Error（錯(cuò)誤）和 Exception（異常），它們通常用于指示發(fā)生了異常情況。
Throwable 包含了其線程創(chuàng)建時(shí)線程執(zhí)行堆棧的快照，它提供了 printStackTrace() 等接口用于獲取堆棧跟蹤數(shù)據(jù)等信息。
2、Error（錯(cuò)誤）
定義：Error 類(lèi)及其子類(lèi)。程序中無(wú)法處理的錯(cuò)誤，表示運(yùn)行應(yīng)用程序中出現(xiàn)了嚴(yán)重的錯(cuò)誤。
特點(diǎn)：此類(lèi)錯(cuò)誤一般表示代碼運(yùn)行時(shí) JVM 出現(xiàn)問(wèn)題。
通常有 Virtual MachineError（虛擬機(jī)運(yùn)行錯(cuò)誤）、NoClassDefFoundError（類(lèi)定義錯(cuò)誤）等。
比如 OutOfMemoryError：內(nèi)存不足錯(cuò)誤；StackOverflowError：棧溢出錯(cuò)誤。此類(lèi)錯(cuò)誤發(fā)生時(shí)，JVM 將終止線程。
這些錯(cuò)誤是不受檢異常，非代碼性錯(cuò)誤。因此，當(dāng)此類(lèi)錯(cuò)誤發(fā)生時(shí)，應(yīng)用程序不應(yīng)該去處理此類(lèi)錯(cuò)誤。
按照 Java 慣例，我們是不應(yīng)該實(shí)現(xiàn)任何新的 Error 子類(lèi)的！
3、Exception（異常）
程序本身可以捕獲并且可以處理的異常。Exception 這種異常又分為兩類(lèi)：運(yùn)行時(shí)異常和編譯時(shí)異常。
運(yùn)行時(shí)異常
定義：RuntimeException 類(lèi)及其子類(lèi)，表示 JVM 在運(yùn)行期間可能出現(xiàn)的異常。
特點(diǎn)：Java 編譯器不會(huì)檢查它。也就是說(shuō)，當(dāng)程序中可能出現(xiàn)這類(lèi)異常時(shí)，倘若既 “沒(méi)有通過(guò)throws聲明拋出它”，也 “沒(méi)有用try-catch語(yǔ)句捕獲它”，還是會(huì)編譯通過(guò)。
比如 NullPointerException 空指針異常、ArrayIndexOutBoundException 數(shù)組下標(biāo)越界異常、ClassCastException 類(lèi)型轉(zhuǎn)換異常、ArithmeticExecption 算術(shù)異常。
此類(lèi)異常屬于不受檢異常，一般是由程序邏輯錯(cuò)誤引起的，在程序中可以選擇捕獲處理，也可以不處理。
雖然 Java 編譯器不會(huì)檢查運(yùn)行時(shí)異常，但是我們也可以通過(guò) throws 進(jìn)行聲明拋出，也可以通過(guò) try-catch 對(duì)它進(jìn)行捕獲處理。
如果產(chǎn)生運(yùn)行時(shí)異常，則需要通過(guò)修改代碼來(lái)進(jìn)行避免。例如，若會(huì)發(fā)生除數(shù)為零的情況，則需要通過(guò)代碼避免該情況的發(fā)生！
RuntimeException 異常會(huì)由 Java 虛擬機(jī)自動(dòng)拋出并自動(dòng)捕獲，就算我們沒(méi)寫(xiě)異常捕獲語(yǔ)句運(yùn)行時(shí)也會(huì)拋出錯(cuò)誤！
此類(lèi)異常的出現(xiàn)絕大數(shù)情況是代碼本身有問(wèn)題，應(yīng)該從邏輯上去解決并改進(jìn)代碼。
編譯時(shí)異常
定義：Exception 中除 RuntimeException 及其子類(lèi)之外的異常。
特點(diǎn)：Java 編譯器會(huì)檢查它。如果程序中出現(xiàn)此類(lèi)異常，比如 ClassNotFoundException（沒(méi)有找到指定的類(lèi)異常），IOException（IO流異常），要么通過(guò) throws 進(jìn)行聲明拋出，要么通過(guò) try-catch 進(jìn)行捕獲處理，否則不能通過(guò)編譯。
在程序中，通常不會(huì)自定義該類(lèi)異常，而是直接使用系統(tǒng)提供的異常類(lèi)。
該異常我們必須手動(dòng)在代碼里添加捕獲語(yǔ)句來(lái)處理該異常。
4、受檢異常與非受檢異常
Java 的所有異常可以分為受檢異常（checked exception）和非受檢異常（uncheckedexception）。
受檢異常
編譯器要求必須處理的異常。
正確的程序在運(yùn)行過(guò)程中，經(jīng)常容易出現(xiàn)的、符合預(yù)期的異常情況。一旦發(fā)生此類(lèi)異常，就必須采用某種方式進(jìn)行處理。
除 RuntimeException 及其子類(lèi)外，其他的 Exception 異常都屬于受檢異常，編譯器會(huì)檢查此類(lèi)異常。
也就是說(shuō)當(dāng)編譯器檢查到應(yīng)用中的某處可能會(huì)此類(lèi)異常時(shí)，將會(huì)提示你處理本異常，
要么使用try-catch捕獲，要么使用方法簽名中用 throws 關(guān)鍵字拋出，否則編譯不通過(guò)。
非受檢異常
編譯器不會(huì)進(jìn)行檢查并且不要求必須處理的異常。
也就說(shuō)當(dāng)程序中出現(xiàn)此類(lèi)異常時(shí)，即使我們沒(méi)有 try-catch 捕獲它，也沒(méi)有使用throws拋出該異常，編譯也會(huì)正常通過(guò)。
該類(lèi)異常包括運(yùn)行時(shí)異常（RuntimeException 及其子類(lèi)）和錯(cuò)誤（Error）。
Java異常關(guān)鍵字
- try：用于監(jiān)聽(tīng)。
將要被監(jiān)聽(tīng)的代碼（可能拋出異常的代碼）放在 try 語(yǔ)句塊之內(nèi)，當(dāng) try 語(yǔ)句塊內(nèi)發(fā)生異常時(shí)，異常就被拋出。
- catch：用于捕獲異常。
catch 用來(lái)捕獲 try 語(yǔ)句塊中發(fā)生的異常。
- finally：finally 語(yǔ)句塊總是會(huì)被執(zhí)行。
它主要用于回收在 try 塊里打開(kāi)的物力資源（如數(shù)據(jù)庫(kù)連接、網(wǎng)絡(luò)連接和磁盤(pán)文件）。
只有 finally 塊，執(zhí)行完成之后，才會(huì)回來(lái)執(zhí)行 try 或者 catch 塊中的 return 或者 throw 語(yǔ)句，
如果 finally 中使用了 return 或者 throw 等終止方法的語(yǔ)句，則就不會(huì)跳回執(zhí)行，直接停止。
- throw：用于拋出異常。
- throws：用在方法簽名中，用于聲明該方法可能拋出的異常。
二、Java異常處理
Java 通過(guò)面向?qū)ο蟮姆椒ㄟM(jìn)行異常處理，一旦方法拋出異常，系統(tǒng)自動(dòng)根據(jù)該異常對(duì)象尋找合適異常處理器（Exception Handler）來(lái)處理該異常，把各種不同的異常進(jìn)行分類(lèi)，并提供了良好的接口。
在 Java 中，每個(gè)異常都是一個(gè)對(duì)象，它是 Throwable 類(lèi)或其子類(lèi)的實(shí)例。
當(dāng)一個(gè)方法出現(xiàn)異常后便拋出一個(gè)異常對(duì)象，該對(duì)象中包含有異常信息，調(diào)用這個(gè)對(duì)象的方法可以捕獲到這個(gè)異常并可以對(duì)其進(jìn)行
處理。
Java 的異常處理是通過(guò) 5 個(gè)關(guān)鍵詞來(lái)實(shí)現(xiàn)的：try、catch、throw、throws 和 finally。
在Java應(yīng)用中，異常的處理機(jī)制分為聲明異常，拋出異常和捕獲異常。
聲明異常
通常，應(yīng)該捕獲那些知道如何處理的異常，將不知道如何處理的異常繼續(xù)傳遞下去。
傳遞異常可以在方法簽名處使用 throws 關(guān)鍵字聲明可能會(huì)拋出的異常。
注意：
- 非檢查異常（Error、RuntimeException 或它們的子類(lèi)）不可使用 throws 關(guān)鍵字來(lái)聲明要拋出的異常。
- 一個(gè)方法出現(xiàn)編譯時(shí)異常，就需要 try-catch/ throws 處理，否則會(huì)導(dǎo)致編譯錯(cuò)誤。
拋出異常
如果你覺(jué)得解決不了某些異常問(wèn)題，且不需要調(diào)用者處理，那么你可以拋出異常。
throw 關(guān)鍵字作用是在方法內(nèi)部拋出一個(gè) Throwable 類(lèi)型的異常。
任何Java代碼都可以通過(guò) throw 語(yǔ)句拋出異常。
捕獲異常
程序通常在運(yùn)行之前不報(bào)錯(cuò)，但是運(yùn)行后可能會(huì)出現(xiàn)某些未知的錯(cuò)誤，但是還不想直接拋出到上一級(jí)，
那么就需要通過(guò) try…catch… 的形式進(jìn)行異常捕獲，之后根據(jù)不同的異常情況來(lái)進(jìn)行相應(yīng)的處理。
如何選擇異常類(lèi)型
可以根據(jù)下圖來(lái)選擇是捕獲異常，聲明異常還是拋出異常
常見(jiàn)異常處理方式
1、直接拋出異常
通常，應(yīng)該捕獲那些知道如何處理的異常，將不知道如何處理的異常繼續(xù)傳遞下去。
傳遞異常可以在方法簽名處使用 throws 關(guān)鍵字聲明可能會(huì)拋出的異常。
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、封裝異常再拋出
有時(shí)我們會(huì)從 catch 中拋出一個(gè)異常，目的是為了改變異常的類(lèi)型。多用于在多系統(tǒng)集成時(shí)，
當(dāng)某個(gè)子系統(tǒng)故障，異常類(lèi)型可能有多種，可以用統(tǒng)一的異常類(lèi)型向外暴露，不需暴露太多內(nèi)部異常細(xì)節(jié)。
自定義一個(gè)異常 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、捕獲異常
在一個(gè) try-catch 語(yǔ)句塊中可以捕獲多個(gè)異常類(lèi)型，并對(duì)不同類(lèi)型的異常做出不同的處理。
public static void readFile(String filePath) {
try {
// do
} catch (FileNotFoundException e) {
// handle FileNotFoundException
} catch (IOException e) {
// handle IOException
}
}
同一個(gè) catch 也可以捕獲多種類(lèi)型異常，用 | 隔開(kāi)
public static void readFile(String filePath) {
try {
// do
} catch (FileNotFoundException | UnknownHostException e) {
// handle FileNotFoundException or UnknownHostException
} catch (IOException e) {
// handle IOException
}
}
4、自定義異常
習(xí)慣上，定義一個(gè)異常類(lèi)應(yīng)包含兩個(gè)構(gòu)造函數(shù)，一個(gè)無(wú)參構(gòu)造函數(shù)和一個(gè)帶有詳細(xì)描述信息的構(gòu)造函數(shù)，
Throwable 的 toString 方法會(huì)打印這些詳細(xì)信息，調(diào)試時(shí)很有用。
public class MyException extends Exception {
public MyException() {
super();
}
public MyException(String message) {
super(message);
}
}
5、try-catch-finally
當(dāng)方法中發(fā)生異常，異常處之后的代碼不會(huì)再執(zhí)行，如果之前獲取了一些本地資源需要釋放，
則需要在方法正常結(jié)束時(shí)和 catch 語(yǔ)句中都調(diào)用釋放本地資源的代碼，顯得代碼比較繁瑣，
finally 語(yǔ)句可以解決這個(gè)問(wèn)題。
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)用該方法時(shí)，讀取文件時(shí)若發(fā)生異常，代碼會(huì)進(jìn)入 catch 代碼塊，之后進(jìn)入 finally 代碼塊；
若讀取文件時(shí)未發(fā)生異常，則會(huì)跳過(guò) catch 代碼塊直接進(jìn)入 finally 代碼塊。
所以無(wú)論代碼中是否發(fā)生異常，fianlly 中的代碼都會(huì)執(zhí)行。
若 catch 代碼塊中包含 return 語(yǔ)句，finally 中的代碼還會(huì)執(zhí)行嗎？將以上代碼中的 catch 子句修改如下：
catch (IOException e) {
System.out.println("catch 代碼塊");
return ;
}
調(diào)用 readFile 方法，觀察當(dāng) catch 子句中調(diào)用 return 語(yǔ)句時(shí)，finally 子句是否執(zhí)行
catch 代碼塊 finally 代碼塊
可見(jiàn)，即使 catch 中包含了 return 語(yǔ)句，finally 子句依然會(huì)執(zhí)行。
若 finally 中也包含 return 語(yǔ)句，finally 中的 return 會(huì)覆蓋前面的 return。
6、try-with-resource
上面例子中，finally 中的 close 方法也可能拋出 IOException，從而覆蓋了原始異常。
JAVA 7 提供了更優(yōu)雅的方式來(lái)實(shí)現(xiàn)資源的自動(dòng)釋放，自動(dòng)釋放的資源需要是實(shí)現(xiàn)了 AutoCloseable 接口的類(lèi)。
public static void tryWithResourceTest() {
try {
Scanner scanner = new Scanner(new FileInputStream("d:/"),"UTF-8");
} catch (IOException e) {
// handle IOException
}
}
try 代碼塊退出時(shí)，會(huì)自動(dòng)調(diào)用 scanner.close 方法，和把 scanner.close 方法放在 finally 代碼塊中不同的是，
若 scanner.close 拋出異常，則會(huì)被抑制，拋出的仍然為原始異常。
被抑制的異常會(huì)由 addSusppressed 方法添加到原來(lái)的異常，如果想要獲取被抑制的異常列表，
可以調(diào)用 getSuppressed 方法來(lái)獲取。
三、Java異常常見(jiàn)面試題
1、Error 和 Exception 區(qū)別是什么？
Error 類(lèi)型的錯(cuò)誤通常為虛擬機(jī)相關(guān)錯(cuò)誤，如系統(tǒng)崩潰，內(nèi)存不足，堆棧溢出等，
編譯器不會(huì)對(duì)這類(lèi)錯(cuò)誤進(jìn)行檢測(cè)，JAVA 應(yīng)用程序也不應(yīng)對(duì)這類(lèi)錯(cuò)誤進(jìn)行捕獲，
一旦這類(lèi)錯(cuò)誤發(fā)生，通常應(yīng)用程序會(huì)被終止，僅靠應(yīng)用程序本身無(wú)法恢復(fù)；
Exception 類(lèi)的錯(cuò)誤是可以在應(yīng)用程序中進(jìn)行捕獲并處理的，通常遇到這種錯(cuò)誤，
應(yīng)對(duì)其進(jìn)行處理，使應(yīng)用程序可以繼續(xù)正常運(yùn)行。
2、運(yùn)行時(shí)異常和一般異常(受檢異常)區(qū)別是什么？
運(yùn)行時(shí)異常包括 RuntimeException 類(lèi)及其子類(lèi)，表示 JVM 在運(yùn)行期間可能出現(xiàn)的異常。
Java 編譯器不會(huì)檢查運(yùn)行時(shí)異常。受檢異常是 Exception 中除 RuntimeException 及其子類(lèi)之外的異常。
Java 編譯器會(huì)檢查受檢異常。
RuntimeException異常和受檢異常之間的區(qū)別：是否強(qiáng)制要求調(diào)用者必須處理此異常，
如果強(qiáng)制要求調(diào)用者必須進(jìn)行處理，那么就使用受檢異常，否則就選擇非受檢異常（RuntimeException）。
一般來(lái)講，如果沒(méi)有特殊的要求，我們建議使用 RuntimeException 異常。
3、JVM 是如何處理異常的？
在一個(gè)方法中如果發(fā)生異常，這個(gè)方法會(huì)創(chuàng)建一個(gè)異常對(duì)象，并轉(zhuǎn)交給 JVM，
該異常對(duì)象包含異常名稱，異常描述以及異常發(fā)生時(shí)應(yīng)用程序的狀態(tài)。
創(chuàng)建異常對(duì)象并轉(zhuǎn)交給 JVM 的過(guò)程稱為拋出異常。
可能有一系列的方法調(diào)用，最終才進(jìn)入拋出異常的方法，這一系列方法調(diào)用的有序列表叫做調(diào)用棧。
JVM 會(huì)順著調(diào)用棧去查找看是否有可以處理異常的代碼，如果有，則調(diào)用異常處理代碼。
當(dāng) JVM 發(fā)現(xiàn)可以處理異常的代碼時(shí)，會(huì)把發(fā)生的異常傳遞給它。
如果 JVM 沒(méi)有找到可以處理該異常的代碼塊，JVM 就會(huì)將該異常轉(zhuǎn)交給默認(rèn)的異常處理器，
默認(rèn)異常處理器為 JVM 的一部分，默認(rèn)異常處理器會(huì)打印出異常信息并終止應(yīng)用程序。
4、throw 和 throws 的區(qū)別是什么？
Java 中的異常處理除了包括捕獲異常和處理異常之外，還包括聲明異常和出異常，
可以通過(guò) throws 關(guān)鍵字在方法上聲明該方法要出的異常，或者在方法內(nèi)部通過(guò) throw 出異常對(duì)象。
throws 關(guān)鍵字和 throw 關(guān)鍵字在使用上的幾點(diǎn)區(qū)別如下：
- throw 關(guān)鍵字用在方法內(nèi)部，只能用于拋出一種異常，用來(lái)拋出方法或代碼塊中的異常，
受查異常和非受查異常都可以被拋出；
- throws 關(guān)鍵字用在方法聲明上，可以拋出多個(gè)異常，用來(lái)標(biāo)識(shí)該方法可能拋出的異常列表。
一個(gè)方法用 throws 標(biāo)識(shí)了可能拋出的異常列表，調(diào)用該方法的方法中必須包含可處理異常的代碼，
否則也要在方法簽名中用 throws 關(guān)鍵字聲明相應(yīng)的異常。
5、final、finally、finalize 有什么區(qū)別？
- final 可以修飾類(lèi)、變量、方法，修飾類(lèi)表示該類(lèi)不能被繼承、修飾方法表示該方法不能被重寫(xiě)、修飾變量
表示該變量是一個(gè)常量不能被重新賦值。
- finally一般作用在 try-catch 代碼塊中，在處理異常的時(shí)候，通常我們將一定要執(zhí)行的代碼方法 finally 代碼
塊中，表示不管是否出現(xiàn)異常，該代碼塊都會(huì)執(zhí)行，一般用來(lái)存放一些關(guān)閉資源的代碼。
- finalize 是一個(gè)方法，屬于 Object 類(lèi)的一個(gè)方法，而 Object 類(lèi)是所有類(lèi)的父類(lèi)，Java 中允許使用 finalize()
方法在垃圾收集器將對(duì)象從內(nèi)存中清除出去之前做必要的清理工作。
6、NoClassDefFoundError 和 ClassNotFoundException 區(qū)別？
NoClassDefFoundError 是一個(gè) Error 類(lèi)型的異常，是由 JVM 引起的，不應(yīng)該嘗試捕獲這個(gè)異常。
引起該異常的原因是 JVM 或 ClassLoader 嘗試加載某類(lèi)時(shí)在內(nèi)存中找不到該類(lèi)的定義，
該動(dòng)作發(fā)生在運(yùn)行期間，即編譯時(shí)該類(lèi)存在，但是在運(yùn)行時(shí)卻找不到了，可能是變異后被刪除了等原因?qū)е拢?/p>
ClassNotFoundException 是一個(gè)受查異常，需要顯式地使用 try-catch 對(duì)其進(jìn)行捕獲和處理，
或在方法簽名中用 throws 關(guān)鍵字進(jìn)行聲明。
當(dāng)使用 Class.forName，ClassLoader.loadClass 或 ClassLoader.findSystemClass 動(dòng)態(tài)加載類(lèi)到內(nèi)存的時(shí)候，
通過(guò)傳入的類(lèi)路徑參數(shù)沒(méi)有找到該類(lèi)，就會(huì)拋出該異常；
另一種拋出該異常的可能原因是某個(gè)類(lèi)已經(jīng)由一個(gè)類(lèi)加載器加載至內(nèi)存中，另一個(gè)加載器又嘗試去加載它。
7、try-catch-finally 中哪個(gè)部分可以省略？
catch 可以省略。
原因
更為嚴(yán)格的說(shuō)法其實(shí)是：try 只適合處理運(yùn)行時(shí)異常，try+catch 適合處理運(yùn)行時(shí)異常+普通異常。
也就是說(shuō)，如果你只用try去處理普通異常卻不加以catch處理，編譯是通不過(guò)的，
因?yàn)榫幾g器硬性規(guī)定，普通異常如果選擇捕獲，則必須用 catch 顯示聲明以便進(jìn)一步處理。
而運(yùn)行時(shí)異常在編譯時(shí)沒(méi)有如此規(guī)定，所以 catch 可以省略，你加上 catch 編譯器也覺(jué)得無(wú)可厚非。
理論上，編譯器看任何代碼都不順眼，都覺(jué)得可能有潛在的問(wèn)題，所以你即使對(duì)所有代碼加上try，
代碼在運(yùn)行期時(shí)也只不過(guò)是在正常運(yùn)行的基礎(chǔ)上加一層皮。
但是你一旦對(duì)一段代碼加上 try，就等于顯示地承諾編譯器，對(duì)這段代碼可能拋出的異常進(jìn)行捕獲，而非向上拋出處理。
如果是普通異常，編譯器要求必須用 catch 捕獲以便進(jìn)一步處理；
如果運(yùn)行時(shí)異常，捕獲然后丟棄并且+ finally 掃尾處理，或者加上 catch 捕獲以便進(jìn)一步處理。
至于加上 finally，則是在不管有沒(méi)捕獲異常，都要進(jìn)行的 “掃尾” 處理。
8、try-catch-finally 中，如果 catch 中 return 了，finally 還會(huì)執(zhí)行嗎？
會(huì)執(zhí)行，在 return 前執(zhí)行。
注意：在 finally 中改變返回值的做法是不好的，因?yàn)槿绻嬖?finally 代碼塊，try中的 return 語(yǔ)句不會(huì)立馬返回調(diào)用者，
而是記錄下返回值待 finally 代碼塊執(zhí)行完畢之后再向調(diào)用者返回其值，然后如果在 finally 中修改了返回值，就會(huì)返回修改后的值。
顯然，在 finally 中返回或者修改返回值會(huì)對(duì)程序造成很大的困擾，C# 中直接用編譯錯(cuò)誤的方式來(lái)阻止程序員干這種事情，
Java 中也可以通過(guò)提升編譯器的語(yǔ)法檢查級(jí)別來(lái)產(chǎn)生警告或錯(cuò)誤。
例子1
public static int getInt() {
int a = 10;
try {
System.out.println(a / 0);
a = 20;
} catch (ArithmeticException e) {
a = 30;
// 程序執(zhí)行到這里時(shí)，不是 return a，而是 return 30，這個(gè)返回路徑已經(jīng)形成
// 但是后面還有 finally，所以繼續(xù)執(zhí)行 finally 內(nèi)容，a = 40
// 再次回到這里，繼續(xù) return 30，形成返回路徑后，這里的 a 就不是變量了，
// 而是常量 30，所以結(jié)果為 30
return a;
} finally {
a = 40;
}
return a;
}
執(zhí)行結(jié)果：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，這樣就重新又形成了一條返回路徑，
// 由于只能通過(guò) 1 個(gè) return 返回，所以這里直接返回 40
return a;
}
}
執(zhí)行結(jié)果：40
9、類(lèi) ExampleA 繼承 Exception，類(lèi) ExampleB 繼承ExampleA。
有如下代碼片斷：
try {
throw new ExampleB("B");
} catch (ExampleA e) {
System.out.println("ExampleA");
} catch (Exception e) {
System.out.println("Exception");
}
請(qǐng)問(wèn)執(zhí)行結(jié)果是什么？
輸出：ExampleA
說(shuō)明：根據(jù)里氏代換原則（能使用父類(lèi)型的地方一定能使用子類(lèi)型），
抓取 ExampleA 類(lèi)型異常的 catch 塊能夠抓住 try 塊中拋出的 ExampleB 類(lèi)型的異常。
10、說(shuō)出下面代碼的運(yùn)行結(jié)果
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");
}
}
}
結(jié)果：
Caught Annoyance
Caught Sneeze
Hello World
11、常見(jiàn)的 RuntimeException 有哪些？
- ClassCastException（類(lèi)轉(zhuǎn)換異常）
- IndexOutOfBoundsException（數(shù)組越界）
- NullPointerException（空指針）
- ArrayStoreException（數(shù)據(jù)存儲(chǔ)異常，操作數(shù)組時(shí)類(lèi)型不一致）
- 還有IO操作的 BufferOverflowException 異常
12、Java常見(jiàn)異常有哪些
- java.lang.IllegalAccessError：違法訪問(wèn)錯(cuò)誤。當(dāng)一個(gè)應(yīng)用試圖訪問(wèn)、修改某個(gè)類(lèi)的域（Field）或者調(diào)用其方法，但是又違反域或方法的可見(jiàn)性聲明，則拋出該異常。
- java.lang.InstantiationError：實(shí)例化錯(cuò)誤。當(dāng)一個(gè)應(yīng)用試圖通過(guò) Java 的 new 操作符構(gòu)造一個(gè)抽象類(lèi)或者接口時(shí)拋出該異常。
- java.lang.OutOfMemoryError：內(nèi)存不足錯(cuò)誤。當(dāng)可用內(nèi)存不足以讓 Java 虛擬機(jī)分配給一個(gè)對(duì)象時(shí)拋出該錯(cuò)誤。
- java.lang.StackOverflowError：堆棧溢出錯(cuò)誤。當(dāng)一個(gè)應(yīng)用遞歸調(diào)用的層次太深而導(dǎo)致堆棧溢出或者陷入死循環(huán)時(shí)拋出該錯(cuò)誤。
- java.lang.ClassCastException：類(lèi)造型異常。假設(shè)有類(lèi) A 和 B（A 不是 B 的父類(lèi)或子類(lèi)），O 是 A 的實(shí)例，那么當(dāng)強(qiáng)制將 O 構(gòu)造為類(lèi)B的實(shí)例時(shí)拋出該異常。該異常經(jīng)常被稱為強(qiáng)制類(lèi)型轉(zhuǎn)換異常。
- java.lang.ClassNotFoundException：找不到類(lèi)異常。當(dāng)應(yīng)用試圖根據(jù)字符串形式的類(lèi)名構(gòu)造類(lèi)，而在遍歷 CLASSPAH 之后找不到對(duì)應(yīng)名稱的 class 文件時(shí)，拋出該異常。
- java.lang.ArithmeticException：算術(shù)條件異常。譬如：整數(shù)除零等。
- java.lang.ArrayIndexOutOfBoundsException：數(shù)組索引越界異常。當(dāng)對(duì)數(shù)組的索引值為負(fù)數(shù)或大于等于數(shù)組大小時(shí)拋出。
- java.lang.IndexOutOfBoundsException：索引越界異常。當(dāng)訪問(wèn)某個(gè)序列的索引值小于0或大于等于序列大小時(shí)，拋出該異常。
- java.lang.InstantiationException：實(shí)例化異常。當(dāng)試圖通過(guò) newInstance() 方法創(chuàng)建某個(gè)類(lèi)的實(shí)例，而該類(lèi)是一個(gè)抽象類(lèi)或接口時(shí)，拋出該異常。
- java.lang.NoSuchFieldException：屬性不存在異常。當(dāng)訪問(wèn)某個(gè)類(lèi)的不存在的屬性時(shí)拋出該異常。
- java.lang.NoSuchMethodException：方法不存在異常。當(dāng)訪問(wèn)某個(gè)類(lèi)的不存在的方法時(shí)拋出該異常。
- java.lang.NullPointerException：空指針異常。當(dāng)應(yīng)用試圖在要求使用對(duì)象的地方使用了 null 時(shí)，拋出該異常。譬如：調(diào)用 null 對(duì)象的實(shí)例方法、訪問(wèn) null 對(duì)象的屬性、計(jì)算 null 對(duì)象的長(zhǎng)度、使用 throw 語(yǔ)句拋出 null 等等。
- java.lang.NumberFormatException：數(shù)字格式異常。當(dāng)試圖將一個(gè) String 轉(zhuǎn)換為指定的數(shù)字類(lèi)型，而該字符串確不滿足數(shù)字類(lèi)型要求的格式時(shí)，拋出該異常。
- java.lang.StringIndexOutOfBoundsException：字符串索引越界異常。當(dāng)使用索引值訪問(wèn)某個(gè)字符串中的字符，而該索引值小于0或大于等于序列大小時(shí)，拋出該異常。
13、Java 異常中 Throwable、Error、Exception、RuntimeException 的區(qū)別
- Throwable 類(lèi)是 Java 語(yǔ)言中所有錯(cuò)誤或異常的超類(lèi)。它的兩個(gè)子類(lèi)是 Error 和 Exception；
- Error 是 Throwable 的子類(lèi)，用于指示合理的應(yīng)用程序不應(yīng)該試圖捕獲的嚴(yán)重問(wèn)題，如內(nèi)存溢出、虛擬機(jī)錯(cuò)誤、棧溢出等。
這類(lèi)錯(cuò)誤一般與硬件有關(guān)，與程序本身無(wú)關(guān)，通常由系統(tǒng)進(jìn)行處理，程序本身無(wú)法捕獲和處理。
OutOfMemoryError 內(nèi)存溢出
java.lang.StackOverflowError 堆棧溢出錯(cuò)誤，當(dāng)一個(gè)應(yīng)用遞歸調(diào)用的層次太深而導(dǎo)致堆棧溢出時(shí)拋出該錯(cuò)誤
- Exception 類(lèi)及其子類(lèi)是 Throwable 的一種形式，合理的應(yīng)用程序想要捕獲的條件，有些異常在編寫(xiě)程序時(shí)無(wú)法預(yù)料的，
如中斷異常、非法存取異常等。為了保證程序的健壯性，Java 要求必須對(duì)這些可能出現(xiàn)的異常進(jìn)行捕獲，并對(duì)其進(jìn)行處理
- RuntimeException 類(lèi)是 Exception 類(lèi)的子類(lèi)（可能在Java虛擬機(jī)正常運(yùn)行期間拋出的異常的超類(lèi)）；
- IOExeption類(lèi)是Exception類(lèi)的子類(lèi)。
四、Java異常處理最佳實(shí)踐
在 Java 中處理異常并不是一個(gè)簡(jiǎn)單的事情。不僅僅初學(xué)者很難理解，即使一些有經(jīng)驗(yàn)的開(kāi)發(fā)者，
也需要花費(fèi)很多時(shí)間來(lái)思考如何處理異常，包括需要處理哪些異常，怎樣處理等等。
這也是絕大多數(shù)開(kāi)發(fā)團(tuán)隊(duì)都會(huì)制定一些規(guī)則來(lái)規(guī)范進(jìn)行異常處理的原因。而團(tuán)隊(duì)之間的這些規(guī)范往往是截然不同的。
本文給出幾個(gè)被很多團(tuán)隊(duì)使用的異常處理最佳實(shí)踐。
1、在 finally 塊中清理資源或者使用 try-with-resource 語(yǔ)句
當(dāng)使用類(lèi)似 InputStream 這種需要使用后關(guān)閉的資源時(shí)，一個(gè)常見(jiàn)的錯(cuò)誤就是在 try 塊的最后關(guān)閉資源。
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(); // 錯(cuò)誤！
} catch (IOException e) {
e.printStackTrace();
}
}
問(wèn)題就是，只有沒(méi)有異常拋出的時(shí)候，這段代碼才可以正常工作。try 代碼塊內(nèi)代碼會(huì)正常執(zhí)行，
并且資源可以正常關(guān)閉。但是，使用 try 代碼塊是有原因的，一般調(diào)用一個(gè)或多個(gè)可能拋出異常的方法，
而且，你自己也可能會(huì)拋出一個(gè)異常，這意味著代碼可能不會(huì)執(zhí)行到 try 代碼塊的最后部分。
結(jié)果就是，并沒(méi)有關(guān)閉資源。所以，應(yīng)該把清理工作的代碼放到 finally 里去，或者使用 try-with-resource 特性。
(1）使用 finally 代碼塊
與前面幾行 try 代碼塊不同，finally 代碼塊總是會(huì)被執(zhí)行。
不管 try 代碼塊成功執(zhí)行之后還是在 catch 代碼塊中處理完異常后都會(huì)執(zhí)行。
因此，可以確保這里清理了所有打開(kāi)的資源。
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 語(yǔ)法
如果你的資源實(shí)現(xiàn)了 AutoCloseable 接口，你可以使用這個(gè)語(yǔ)法。大多數(shù)的 Java 標(biāo)準(zhǔn)資源都繼承了這個(gè)接口。
當(dāng)你在 try 子句中打開(kāi)資源，資源會(huì)在 try 代碼塊執(zhí)行后或異常處理后自動(dòng)關(guān)閉。
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)先明確的異常
你拋出的異常越明確越好，永遠(yuǎn)記住，你的同事或者幾個(gè)月之后的你，將會(huì)調(diào)用你的方法并且處理異常。
因此需要保證提供給他們盡可能多的信息。這樣你的 API 更容易被理解。
你的方法的調(diào)用者能夠更好的處理異常并且避免額外的檢查。因此，總是嘗試尋找最適合你的異常事件的類(lèi)。
例如，拋出一個(gè) NumberFormatException ，來(lái)替換一個(gè) IllegalArgumentException 。避免拋出一個(gè)不明確的異常。
public void doNotDoThis() throws Exception {
}
public void doThis() throws NumberFormatException {
}
3、對(duì)異常進(jìn)行文檔說(shuō)明
當(dāng)在方法上聲明拋出異常時(shí)，也需要進(jìn)行文檔說(shuō)明。目的是為了給調(diào)用者提供盡可能多的信息，
從而可以更好地避免或處理異常。在 Javadoc 添加 @throws 聲明，并且描述拋出異常的場(chǎng)景。
4、使用描述性消息拋出異常
在拋出異常時(shí)，需要盡可能精確地描述問(wèn)題和相關(guān)信息，這樣無(wú)論是打印到日志中還是在監(jiān)控工具中，
都能夠更容易被人閱讀，從而可以更好地定位具體錯(cuò)誤信息、錯(cuò)誤的嚴(yán)重程度等。
但這里并不是說(shuō)要對(duì)錯(cuò)誤信息長(zhǎng)篇大論，因?yàn)楸緛?lái) Exception 的類(lèi)名就能夠反映錯(cuò)誤的原因，因此只需要用一到兩句話描述即可。
如果拋出一個(gè)特定的異常，它的類(lèi)名很可能已經(jīng)描述了這種錯(cuò)誤。所以你不需要提供很多額外的信息。
一個(gè)很好的例子是 NumberFormatException 。當(dāng)你以錯(cuò)誤的格式提供 String 時(shí)，它將被 java.lang.Long 類(lèi)的構(gòu)造函數(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 都可以幫助你實(shí)現(xiàn)這個(gè)最佳實(shí)踐。當(dāng)你嘗試首先捕獲較不具體的異常時(shí)，它們會(huì)報(bào)告無(wú)法訪問(wèn)的代碼塊。
但問(wèn)題在于，只有匹配異常的第一個(gè) catch 塊會(huì)被執(zhí)行。
因此，如果首先捕獲 IllegalArgumentException，則永遠(yuǎn)不會(huì)到達(dá)應(yīng)該處理更具體的 NumberFormatException 的 catch 塊，
因?yàn)樗?IllegalArgumentException 的子類(lèi)。
總是優(yōu)先捕獲最具體的異常類(lèi)，并將不太具體的 catch 塊添加到列表的末尾。
public static void catchMostSpecificExceptionFirst() {
try {
// do
} catch (NumberFormatException e) {
// handle NumberFormatException
} catch (IllegalArgumentException e) {
// handle IllegalArgumentException
}
}
6、不要捕獲 Throwable 類(lèi)
Throwable 是所有異常和錯(cuò)誤的超類(lèi)。你可以在 catch 子句中使用它，但是你永遠(yuǎn)不應(yīng)該這樣做！
如果在 catch 子句中使用 Throwable ，它不僅會(huì)捕獲所有異常，也將捕獲所有的錯(cuò)誤。
JVM 拋出錯(cuò)誤，指出不應(yīng)該由應(yīng)用程序處理的嚴(yán)重問(wèn)題。
典型的例子是 OutOfMemoryError 或者 StackOverflowError 。
兩者都是由應(yīng)用程序控制之外的情況引起的，無(wú)法處理。所以，最好不要捕獲 Throwable ，
除非你確定自己處于一種特殊的情況下能夠處理錯(cuò)誤。
7、不要忽略異常
很多時(shí)候，開(kāi)發(fā)者很有自信不會(huì)拋出異常，因此寫(xiě)了一個(gè)catch塊，但是沒(méi)有做任何處理或者記錄日志。
public void doNotIgnoreExceptions() {
try{
// do
} catch (NumberFormatException e){
// this will neverhappen
}
}
但現(xiàn)實(shí)是經(jīng)常會(huì)出現(xiàn)無(wú)法預(yù)料的異常，或者無(wú)法確定這里的代碼未來(lái)是不是會(huì)改動(dòng)（刪除了阻止異常拋出的代碼），
而此時(shí)由于異常被捕獲，使得無(wú)法拿到足夠的錯(cuò)誤信息來(lái)定位問(wèn)題。合理的做法是至少要記錄異常的信息。
public void logAnException() {
try{
// do
} catch (NumberFormatException e){
log.error("This should never happen: "+ e)
}
}
8、不要記錄并拋出異常
這可能是最常被忽略的最佳實(shí)踐。可以發(fā)現(xiàn)很多代碼甚至類(lèi)庫(kù)中都會(huì)有捕獲異常、記錄日志并再次拋出的邏輯。
try {
new Long("xxx");
} catch (NumberFormatException e) {
log.error(e);
throw e;
}
這個(gè)處理邏輯看著是合理的。但這經(jīng)常會(huì)給同一個(gè)異常輸出多條日志。
多余的日志也沒(méi)有附加更有用的信息。如果想要提供更加有用的信息，那么可以將異常包裝為自定義異常。
public void wrapException(String input) throws MyException {
try {
// do
} catch(NumberFormatException e) {
throw new MyException("A message that describesthe error.", e);
}
}
因此，僅僅當(dāng)想要處理異常時(shí)才去捕獲，否則只需要在方法簽名中聲明讓調(diào)用者去處理。
9、包裝異常時(shí)不要拋棄原始的異常
捕獲標(biāo)準(zhǔn)異常并包裝為自定義異常是一個(gè)很常見(jiàn)的做法。這樣可以添加更為具體的異常信息并能夠做針對(duì)的異常處理。
在你這樣做時(shí)，請(qǐng)確保將原始異常設(shè)置為原因（注：參考下方代碼 NumberFormatException e 中的原始異常 e ）。
Exception 類(lèi)提供了特殊的構(gòu)造函數(shù)方法，它接受一個(gè) Throwable 作為參數(shù)。
否則，你將會(huì)丟失堆棧跟蹤和原始異常的消息，這將會(huì)使分析導(dǎo)致異常的異常事件變得困難。
public void wrapException(String input) throws MyException {
try {
// do
} catch(NumberFormatException e) {
throw new MyException("A message that describesthe error.", e);
// 等價(jià)于
// MyException myException = new MyException("A message that describesthe error.");
// myException.initCause(e);
// throw myException;
}
}
10、不要使用異常控制程序的流程
不應(yīng)該使用異常控制應(yīng)用的執(zhí)行流程，例如，本應(yīng)該使用if語(yǔ)句進(jìn)行條件判斷的情況下，
你卻使用異常處理，這是非常不好的習(xí)慣，會(huì)嚴(yán)重影響應(yīng)用的性能。
11、使用標(biāo)準(zhǔn)異常
如果使用內(nèi)建的異常可以解決問(wèn)題，就不要定義自己的異常。
Java API 提供了上百種針對(duì)不同情況的異常類(lèi)型，在開(kāi)發(fā)中首先盡可能使用 Java API 提供的異常，
如果標(biāo)準(zhǔn)的異常不能滿足你的要求，這時(shí)候創(chuàng)建自己的定制異常。盡可能得使用標(biāo)準(zhǔn)異常有利于新加入的開(kāi)發(fā)者看懂項(xiàng)目代碼。
12、異常會(huì)影響性能
異常處理的性能成本非常高，每個(gè) Java 程序員在開(kāi)發(fā)時(shí)都應(yīng)牢記這句話。
創(chuàng)建一個(gè)異常非常慢，拋出一個(gè)異常又會(huì)消耗1~5ms，
當(dāng)一個(gè)異常在應(yīng)用的多個(gè)層級(jí)之間傳遞時(shí)，會(huì)拖累整個(gè)應(yīng)用的性能。
- 僅在異常情況下使用異常；
- 在可恢復(fù)的異常情況下使用異常；
盡管使用異常有利于 Java 開(kāi)發(fā)，但是在應(yīng)用中最好不要捕獲太多的調(diào)用棧，
因?yàn)樵诤芏嗲闆r下都不需要打印調(diào)用棧就知道哪里出錯(cuò)了。
因此，異常消息應(yīng)該提供恰到好處的信息。
13、總結(jié)
綜上所述，當(dāng)你拋出或捕獲異常的時(shí)候，有很多不同的情況需要考慮，
而且大部分事情都是為了改善代碼的可讀性或者 API 的可用性。
異常不僅僅是一個(gè)錯(cuò)誤控制機(jī)制，也是一個(gè)通信媒介。
因此，為了和同事更好的合作，一個(gè)團(tuán)隊(duì)必須要制定出一個(gè)最佳實(shí)踐和規(guī)則，
只有這樣，團(tuán)隊(duì)成員才能理解這些通用概念，同時(shí)在工作中使用它。
五、異常處理-阿里巴巴Java開(kāi)發(fā)手冊(cè)
到此這篇關(guān)于超詳細(xì)講解Java異常的文章就介紹到這了,更多相關(guān)Java異常內(nèi)容請(qǐng)搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
原文鏈接：https://blog.csdn.net/qq_44290077/article/details/119739890
