聊一聊Java 異常處理基礎(chǔ)篇
本文轉(zhuǎn)載自微信公眾號「蝸牛互聯(lián)網(wǎng)」，作者白色蝸牛。轉(zhuǎn)載本文請聯(lián)系蝸牛互聯(lián)網(wǎng)公眾號。
閱讀本文你將收獲：
什么是異常
我們?nèi)粘Ｉ钪薪?jīng)常會遇到一些意外的事情，比如坐火車沒帶身份證，那你就無法順利上車。
計算機世界也有類似的情形，術(shù)語是異常(Exception)，其實是異常事件(Exception Event)的縮寫。
一個異常就是一個事件，它發(fā)生在程序執(zhí)行過程中，會中斷程序的正常運行。好比你上火車沒有身份證，這就是個異常事件，這個事件會阻擋你正常上火車。
計算機程序運行會有個主入口，一般我們稱為 main 方法，main 方法內(nèi)部也可能調(diào)用各種其它方法。當某個方法發(fā)生錯誤時，這個方法就會創(chuàng)建一個對象，并把它移交給運行時的系統(tǒng)。這個對象就稱為異常對象，它包含了錯誤相關(guān)的信息，包括錯誤類型和程序狀態(tài)。
創(chuàng)建異常對象并將其交給運行時系統(tǒng)這個操作就稱為拋出異常。
當方法拋出異常后，運行時系統(tǒng)會嘗試找到處理異常的方法。首先系統(tǒng)會判斷，錯誤發(fā)生的方法有沒有處理，如果沒有，會把異常往上層方法拋，直到找到有異常處理的方法。這樣的話，從錯誤發(fā)生的方法到異常處理的方法之間，就會形成調(diào)用方法的有序列表。
這個方法列表就稱為調(diào)用堆棧(call stack)。應(yīng)用程序的每個方法會按調(diào)用順序進棧，棧是先進后出的，比如 main 方法先進棧，開始執(zhí)行程序，遇到其他方法的調(diào)用，其他方法也進棧，其他方法執(zhí)行完畢，其他方法出棧，繼續(xù)執(zhí)行 main 方法，main 方法執(zhí)行完畢就出棧，棧空，程序運行結(jié)束。
運行時系統(tǒng)會在調(diào)用堆棧中尋找包含可以處理異常的代碼塊的方法，這段代碼就稱為異常處理程序。通過調(diào)用堆棧，從錯誤發(fā)生的方法開始，按照方法調(diào)用相反的順序?qū)ふ?棧有先進后出的特點)。當找到合適的異常處理程序時，運行時系統(tǒng)就會把異常傳遞給處理程序。如果拋出的異常對象的類型和處理程序可以處理的類型相匹配，就認為異常處理程序是適當?shù)摹?/p>
選中異常處理程序的過程就稱為捕獲異常。
如果運行時系統(tǒng)找遍了調(diào)用堆棧上的所有方法，依然沒有找到適當?shù)漠惓Ｌ幚沓绦颍敲催\行時系統(tǒng)(以及隨后的程序)將終止。
觀察以下代碼，想想運行情況是怎樣的?
- package com.springtest.demo;
- public class Test {
- /**
- * 程序主方法
- *
- * @param args 程序入?yún)?nbsp;
- */
- public static void main(String[] args) {
- // 用戶輸入字符串 woniu
- String woniu = "woniu";
- int num = str2number(woniu);
- System.out.println(num);
- }
- /**
- * str 轉(zhuǎn) 整數(shù)
- *
- * @param str 字符串
- * @return 整數(shù)
- */
- private static int str2number(String str) {
- // 解析成數(shù)字，拋 NumberFormatException
- return Integer.parseInt(str);
- }
- }
輸出是這樣的：
- Exception in thread "main" java.lang.NumberFormatException: For input string: "woniu"
- at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
- at java.lang.Integer.parseInt(Integer.java:580)
- at java.lang.Integer.parseInt(Integer.java:615)
- at com.springtest.demo.Test.str2number(Test.java:29)
- at com.springtest.demo.Test.main(Test.java:15)
觀察運行的結(jié)果信息，我們發(fā)現(xiàn)應(yīng)用主程序出現(xiàn)異常了，并且程序終止掉了，因為 num 的值并沒有打印。
結(jié)果里也告知我們是出現(xiàn)了 NumberFormatException，也就是數(shù)字格式異常，后邊也給到了提示，woniu 這個字符串是轉(zhuǎn)換不了數(shù)字的。這符合我們的預(yù)期。
然后就是調(diào)用堆棧，調(diào)用堆棧里的每一行信息都標明了異常流轉(zhuǎn)過程中所在的方法路徑，類名以及代碼行數(shù)。
其中第一行信息就是異常最先發(fā)生的地方，這也可以作為我們異常排查的依據(jù)。
很明顯，在 forInputString 拋出異常后，parseInt 和 str2number 都只是轉(zhuǎn)發(fā)異常，并沒有捕獲異常，甚至在 main 方法中，也沒捕獲異常。最后因為沒有異常處理程序，而導(dǎo)致程序運行終止。
如何捕獲和處理異常
為了程序能夠正常運行不被意外終止，Java 編程規(guī)范就有要求：異常必須要捕獲或者指定。
使用 try
捕獲異常的第一步是用 try 把可能引發(fā)異常的代碼括起來。
語法如下：
- try {
- // 可能引發(fā)異常的代碼
- }
try 包括了一個代碼塊，你可以把可能引發(fā)異常的代碼放里邊。代碼可以是一行，也可以是多行。這也意味著這個代碼塊可能引發(fā)多種不同的異常。
異常處理程序只有 try 是無法通過編譯的。你用 javac 命令編譯只有 try 的 java 文件，會報以下錯誤：
錯誤: 'try' 不帶有 'catch', 'finally' 或資源聲明
- 錯誤: 'try' 不帶有 'catch', 'finally' 或資源聲明
- try {
- ^
- 1 個錯誤
所以 try 代碼塊只是圈定了捕獲異常的范圍，只靠 try 做異常管理顯然不夠。
使用 catch
catch 語法
因此捕獲異常就需要第二步：用 catch 捕獲異常和異常處理。
語法如下：
- try {
- // 可能引發(fā)異常的代碼
- } catch (ExceptionType1 name1) {
- // 命中異常類型1 ExceptionType1 時的異常處理代碼
- } catch (ExceptionType2 name2) {
- // 命中異常類型2 ExceptionType2 時的異常處理代碼
- }
catch 是搭配 try 使用的，不單獨出現(xiàn)。try 后邊可以跟多個 catch 代碼塊，以處理 try 中出現(xiàn)的多種類型的異常。
每個 catch 代碼塊都是一個異常處理程序，處理的時候由 catch 的參數(shù)指定異常類型。
catch 的圓括號里，參數(shù) ExceptionType 聲明了這個處理程序可以處理的異常類型，這個異常類型必須是從 Throwable 類繼承的類。
Java 異常的繼承體系
提到 Throwable 就不得不說 Java 的異常體系。以下是 Java 異常的繼承體系圖。
Throwable 是異常體系的根，它繼承自 Object。Throwable 又拆分成兩個體系：Error 和 Exception。
Error 表示嚴重的錯誤，程序一般無法處理，比如表示棧溢出的 StackOverflowError。
Exception 表示運行時的錯誤，它是可以被捕獲并處理的。Exception 又可以拆分為兩類：RuntimeException 和 Checked Exception。
RuntimeException 指運行時異常，它是程序邏輯編寫不對造成的，比如表示空指針異常的 NullPointerException 以及表示數(shù)組索引越界的 IndexOutOfBoundsException。出現(xiàn)這種異常就是代碼 Bug，應(yīng)該修復(fù)程序代碼。
- int[] arrry = {0,1,2};
- // 此處會拋 java.lang.ArrayIndexOutOfBoundsException，不應(yīng)該出現(xiàn) arrry[3] 這樣的代碼
- System.out.println(arrry[3]);
Checked Exception 指檢測型異常，它是程序邏輯的一部分。比如表示 IO 異常的 IOException 以及表示文件找不到的 FileNotFoundException。這種異常必須捕獲并處理，否則編譯會失敗。
以下代碼是不能編譯通過的：
- public class A {
- public static void main(String[] args) {
- FileInputStream inputStream = new FileInputStream("/");
- }
- }
javac 編譯會報以下錯誤，也會提示你必須用 try/catch 捕獲或者把異常添加到聲明里方便拋出。
- 錯誤: 未報告的異常錯誤FileNotFoundException; 必須對其進行捕獲或聲明以便拋出
- FileInputStream inputStream = new FileInputStream("/");
- ^
- 1 個錯誤
catch 使用
回到 catch 語法中，ExceptionType 對應(yīng)的就是 Java 異常體系中的 Exception 類或者它的子類。
name 是為異常類型起的名稱，花括號里的內(nèi)容就是調(diào)用異常處理程序時執(zhí)行的代碼，這里的代碼可以通過 name 這個名稱引用異常。
當調(diào)用堆棧出現(xiàn)異常時，運行時系統(tǒng)會調(diào)用異常處理程序，當異常處理程序的 ExceptionType 和引發(fā)異常的類型匹配時，即命中某個 catch 塊，就會把異常對象分配給異常處理程序的參數(shù)，進而執(zhí)行 catch 塊的異常處理代碼。
異常處理程序我們可以做很多事情，比如打印錯誤日志，暫停程序，執(zhí)行錯誤恢復(fù)，也可以提示給用戶，或者把異常往上層傳遞。以下是打印錯誤信息的示例代碼：
- public static void main(String[] args) {
- try {
- int[] arrry = {0, 1, 2};
- // 此處會拋 java.lang.ArrayIndexOutOfBoundsException，不應(yīng)該出現(xiàn) arrry[3] 這樣的代碼
- System.out.println(arrry[3]);
- } catch (IndexOutOfBoundsException e) {
- System.out.println("捕獲到數(shù)組越界異常：");
- System.out.println(e);
- }
- }
輸出結(jié)果為：
- 捕獲到數(shù)組越界異常：
- java.lang.ArrayIndexOutOfBoundsException: 3
有些場景，我們的一段代碼可能引發(fā)多種異常，而異常的處理會比較一致，比如都是打印日志，這種情況下，如果都單獨設(shè)置一個 catch 塊，寫相同的代碼，重復(fù)度就很高。
因此在 Java 7 之后，一個 catch 塊就支持處理多種類型的異常。語法如下：
- try {
- // 可能引發(fā)異常的代碼
- } catch (ExceptionType1 name1 | ExceptionType2 name2) {
- // 命中異常類型1 ExceptionType1 或異常類型2 ExceptionType2 時的異常處理代碼
- }
使用 finally
程序在運行的時候有時候會打開一些資源，比如文件，連接，線程等等。如果程序運行中途拋異常，程序終止，打開的資源就永遠得不到釋放了，這會導(dǎo)致資源泄漏，甚至系統(tǒng)崩潰。
再比如，程序運行結(jié)束前，我要輸出一個摘要日志做監(jiān)控，但如果運行中途拋異常，程序終止，日志就不會打印，我也看不到我想要的信息。
因此需要有種機制，能夠支持在異常發(fā)生，阻斷流程的時候，也能把打開的資源釋放掉或者執(zhí)行指定的邏輯。
Java 用 finally 來達成這種目的，finally 可以形成try-finally 結(jié)構(gòu)，也可以形成 try-catch-finally 結(jié)構(gòu)。但是 finally 代碼塊總是在 try 退出時執(zhí)行。
這個「總是」可以分為以下幾種情況：
無異常
try 執(zhí)行完畢，未發(fā)生異常，然后執(zhí)行 finally 代碼塊，像普通程序一樣順序執(zhí)行。
- public static void main(String[] args) {
- System.out.println("main:" + fetchMyName());
- }
- public static String fetchMyName() {
- String me = "woniu";
- try {
- me = "woniu666";
- } finally {
- System.out.println("finally: " + me);
- }
- return me;
- }
輸出：
- finally: woniu666
- main:woniu666
有異常未捕獲
try 執(zhí)行過程中出現(xiàn)異常，會把異常對象拋出，但 finally 代碼塊依然會執(zhí)行。
- public static void main(String[] args) {
- System.out.println("main:" + fetchMyName());
- }
- public static String fetchMyName() {
- String me = "woniu";
- int[] arrry = {0, 1, 2};
- try {
- me = "woniu666";
- // 此處會拋 java.lang.ArrayIndexOutOfBoundsException，不應(yīng)該出現(xiàn) arrry[3] 這樣的代碼
- System.out.println(arrry[3]);
- } finally {
- System.out.println("finally: " + me);
- }
- return me;
- }
fetchMyName() 未捕獲到異常，就往上拋，但會把 finally 里的邏輯先執(zhí)行掉，在 main 方法中同樣沒有捕獲異常，于是就阻斷了程序，打印出了調(diào)用堆棧。
- finally: woniu666
- Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
- at com.springtest.demo.TryFinally.fetchMyName(TryFinally.java:28)
- at com.springtest.demo.TryFinally.main(TryFinally.java:15)
有異常有捕獲
try 執(zhí)行過程中出現(xiàn)異常，會把異常對象拋出，catch 捕獲異常并正常處理，此時 finally 代碼塊依然會執(zhí)行。
- public static void main(String[] args) {
- System.out.println("main:" + fetchMyName());
- }
- public static String fetchMyName() {
- String me = "woniu";
- int[] arrry = {0, 1, 2};
- try {
- me = "woniu666";
- // 此處會拋 java.lang.ArrayIndexOutOfBoundsException，不應(yīng)該出現(xiàn) arrry[3] 這樣的代碼
- System.out.println(arrry[3]);
- } catch (ArrayIndexOutOfBoundsException e) {
- System.out.println("命中數(shù)組索引越界異常的處理器，越界索引為：" + e.getMessage());
- } finally {
- System.out.println("finally: " + me);
- }
- return me;
- }
代碼正常運行，先執(zhí)行了 catch 代碼塊中的邏輯，然后執(zhí)行了 finally 代碼塊，最后執(zhí)行 main 方法。
- 命中數(shù)組索引越界異常的處理器，越界索引為：3
- finally: woniu666
- main:woniu666
try 中 return
return 意味著方法執(zhí)行結(jié)束，而 finally 是在 try 退出時執(zhí)行，那如果 try 代碼塊中帶 return，finally 代碼塊還會執(zhí)行到么?
try 代碼塊加個 return 試試!
- public static void main(String[] args) {
- System.out.println("main:" + fetchMyName());
- }
- public static String fetchMyName() {
- String me = "woniu";
- int[] arrry = {0, 1, 2};
- try {
- me = "woniu666";
- // 此處不拋異常
- System.out.println(arrry[0]);
- return "try";
- } catch (ArrayIndexOutOfBoundsException e) {
- System.out.println("命中數(shù)組索引越界異常的處理器，越界索引為：" + e.getMessage());
- } finally {
- System.out.println("finally: " + me);
- }
- return me;
- }
看結(jié)果依然會走到 finally 代碼塊的執(zhí)行!
- 0
- finally: woniu666
- main:try
catch 中 return
try 中 return 我們試了，那 catch 中 return，finally 的執(zhí)行是啥樣的呢?
- public static void main(String[] args) {
- System.out.println("main:" + fetchMyName());
- }
- public static String fetchMyName() {
- String me = "woniu";
- int[] arrry = {0, 1, 2};
- try {
- me = "woniu666";
- // 此處會拋 java.lang.ArrayIndexOutOfBoundsException，不應(yīng)該出現(xiàn) arrry[3] 這樣的代碼
- System.out.println(arrry[3]);
- } catch (ArrayIndexOutOfBoundsException e) {
- System.out.println("命中數(shù)組索引越界異常的處理器，越界索引為：" + e.getMessage());
- return "catch";
- } finally {
- System.out.println("finally: " + me);
- }
- return me;
- }
看結(jié)果依然會走到 finally 代碼塊的執(zhí)行!
- 命中數(shù)組索引越界異常的處理器，越界索引為：3
- finally: woniu666
- main:catch
如何指定方法拋出的異常
異常捕獲的知識介紹完之后，你想象另外一種情況，就是當前方法拋出異常后，但是呢，當前方法不適合處理這個異常，而調(diào)用堆棧上層的方法更適合處理。那其實當前方法最好就不要捕獲異常，并能夠允許調(diào)用堆棧上層的方法處理它。
此時，如果拋出的異常是 檢查型異常，那你就必須在方法上指定它可以拋出這些異常。你需要在方法聲明中添加一個 throws 語句。throws 語句包含 throws 關(guān)鍵字，后面跟著由該方法一引發(fā)的所有異常，多個異常用逗號分隔。throws 語句放在方法名和參數(shù)列表之后，放在定義方法范圍的圓括號之前。
代碼示例如下：
- public static void test() throws FileNotFoundException {
- FileInputStream inputStream = new FileInputStream("/");
- }
由上層 main 方法捕獲處理：
- public static void main(String[] args) {
- try {
- test();
- } catch (FileNotFoundException e) {
- System.out.println("文件找不到異常：" + e.getMessage());
- }
- }
可以正常輸出：
- 文件找不到異常：/ (Is a directory)
前邊說檢查型異常必須要處理，是因為不處理會編譯不通過，要么捕獲和處理異常，要么指定方法拋出的異常，
那非檢查型異常，也就是運行時異常也有這種要求么?
非檢查型異常并不強制，你可以指定方法拋出的異常，也可以不指定，不指定的時候，異常對象會不停的沿著調(diào)用堆棧向上層拋，直到被捕獲處理或者程序終止。
小結(jié)
本文介紹了異常的概念，我們了解到了異常相關(guān)的術(shù)語，異常出現(xiàn)的背景以及異常的運行機制，接著我們按照 Java 編程規(guī)范分別介紹了異常如何捕獲以及異常如何指定，同時也介紹了 Java 異常的繼承體系。這些都是非常基礎(chǔ)的內(nèi)容，卻也非常重要，寫代碼的時候必須要考慮這方面，甚至你可以認為，面向異常編程非常考驗?zāi)愕木幋a功底。
