一、引子

try…catch…finally恐怕是大家再熟悉不過的語句了，而且感覺用起來也是很簡單，邏輯上似乎也是很容易理解。不過，我親自體驗(yàn)的“教訓(xùn)”告訴我，這個東西可不是想象中的那么簡單、聽話。不信？那你看看下面的代碼，“猜猜”它執(zhí)行后的結(jié)果會是什么？不要往后看答案、也不許執(zhí)行代碼看真正答案哦。如果你的答案是正確，那么這篇文章你就不用浪費(fèi)時間看啦。

1 packageexception;2

3 /**

4 *@authorzsh5 * @company wlgzs6 * @create 2019-03-01 10:077 * @Describe 異常處理測試8 */

9 public classTestException {10

11 boolean testEx() throwsException {12 boolean ret = true;13 try{14 ret =testEx1();15 } catch(Exception e) {16 System.out.println("testEx, catch exception");17 ret = false;18 throwe;19 } finally{20 System.out.println("testEx, finally; return value=" +ret);21 returnret;22 }23 }24 boolean testEx1() throwsException {25 boolean ret = true;26 try{27 ret =testEx2();28 if (!ret) {29 return false;30 }31 System.out.println("testEx1, at the end of try");32 returnret;33 } catch(Exception e) {34 System.out.println("testEx1, catch exception");35 ret = false;36 throwe;37 } finally{38 System.out.println("testEx1, finally; return value=" +ret);39 returnret;40 }41 }42 boolean testEx2() throwsException {43 boolean ret = true;44 try{45 int b = 12;46 intc;47 for (int i = 2; i >= -2; i--) {48 c = b /i;49 System.out.println("i=" +i);50 }51 return true;52 } catch(Exception e) {53 System.out.println("testEx2, catch exception");54 ret = false;55 throwe;56 } finally{57 System.out.println("testEx2, finally; return value=" +ret);58 returnret;59 }60 }61 public static voidmain(String[] args) {62 TestException testException1 = newTestException();63 try{64 testException1.testEx();65 } catch(Exception e) {66 e.printStackTrace();67 }68 }69 }

你的答案是什么？是下面的答案嗎？

i=2

i=1

testEx2, catch exception

testEx2, finally; return value=false

testEx1, catch exception

testEx1, finally; return value=false

testEx, catch exception

testEx, finally; return value=false

如果你的答案真的如上面所說，那么你錯啦。^_^，那就建議你仔細(xì)看一看這篇文章或者拿上面的代碼按各種不同的情況修改、執(zhí)行、測試，你會發(fā)現(xiàn)有很多事情不是原來想象中的那么簡單的。現(xiàn)在公布正確答案：

注意說明：finally語句塊不應(yīng)該出現(xiàn) 應(yīng)該出現(xiàn)return。上面的return ret最好是其他語句來處理相關(guān)邏輯。

二、JAVA異常

異常指不期而至的各種狀況，如：文件找不到、網(wǎng)絡(luò)連接失敗、非法參數(shù)等。異常是一個事件，它發(fā)生在程序運(yùn)行期間，干擾了正常的指令流程。Java通 過API中Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是對象，是Throwable子類的實(shí)例，描述了出現(xiàn)在一段編碼中的 錯誤條件。當(dāng)條件生成時，錯誤將引發(fā)異常。

Java異常類層次結(jié)構(gòu)圖：

在 Java 中，所有的異常都有一個共同的祖先 Throwable(可拋出)。Throwable 指定代碼中可用異常傳播機(jī)制通過 Java 應(yīng)用程序傳輸?shù)娜魏螁栴}的共性。

Throwable： 有兩個重要的子類：Exception(異常)和 Error(錯誤)，二者都是 Java 異常處理的重要子類，各自都包含大量子類。

Error(錯誤):是程序無法處理的錯誤，表示運(yùn)行應(yīng)用程序中較嚴(yán)重問題。大多數(shù)錯誤與代碼編寫者執(zhí)行的操作無關(guān)，而表示代碼運(yùn)行時 JVM(Java 虛擬機(jī))出現(xiàn)的問題。例如，Java虛擬機(jī)運(yùn)行錯誤(Virtual MachineError)，當(dāng) JVM 不再有繼續(xù)執(zhí)行操作所需的內(nèi)存資源時，將出現(xiàn) OutOfMemoryError。這些異常發(fā)生時，Java虛擬機(jī)(JVM)一般會選擇線程終止。

這些錯誤表示故障發(fā)生于虛擬機(jī)自身、或者發(fā)生在虛擬機(jī)試圖執(zhí)行應(yīng)用時，如Java虛擬機(jī)運(yùn)行錯誤(Virtual MachineError)、類定義錯誤(NoClassDefFoundError)等。這些錯誤是不可查的，因?yàn)樗鼈冊趹?yīng)用程序的控制和處理能力之 外，而且絕大多數(shù)是程序運(yùn)行時不允許出現(xiàn)的狀況。對于設(shè)計合理的應(yīng)用程序來說，即使確實(shí)發(fā)生了錯誤，本質(zhì)上也不應(yīng)該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。

Exception(異常):是程序本身可以處理的異常。

Exception 類有一個重要的子類 RuntimeException。RuntimeException 類及其子類表示“JVM 常用操作”引發(fā)的錯誤。例如，若試圖使用空值對象引用、除數(shù)為零或數(shù)組越界，則分別引發(fā)運(yùn)行時異常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。

注意：異常和錯誤的區(qū)別：異常能被程序本身可以處理，錯誤是無法處理。

通常，Java的異常(包括Exception和Error)分為可查的異常(checked exceptions)和不可查的異常(unchecked exceptions)。

可查異常(編譯器要求必須處置的異常)：正確的程序在運(yùn)行中，很容易出現(xiàn)的、情理可容的異常狀況。可查異常雖然是異常狀況，但在一定程度上它的發(fā)生是可以預(yù)計的，而且一旦發(fā)生這種異常狀況，就必須采取某種方式進(jìn)行處理。

除了RuntimeException及其子類以外，其他的Exception類及其子類都屬于可查異常。這種異常的特點(diǎn)是Java編譯器會檢查它，也就是說，當(dāng)程序中可能出現(xiàn)這類異常，要么用try-catch語句捕獲它，要么用throws子句聲明拋出它，否則編譯不會通過。

不可查異常(編譯器不要求強(qiáng)制處置的異常):包括運(yùn)行時異常(RuntimeException與其子類)和錯誤(Error)。

Exception 這種異常分兩大類運(yùn)行時異常和非運(yùn)行時異常(編譯異常)。程序中應(yīng)當(dāng)盡可能去處理這些異常。

運(yùn)行時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標(biāo)越界異常)等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應(yīng)該從邏輯角度盡可能避免這類異常的發(fā)生。

運(yùn)行時異常的特點(diǎn)是Java編譯器不會檢查它，也就是說，當(dāng)程序中可能出現(xiàn)這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。

非運(yùn)行時異常?(編譯異常)：是RuntimeException以外的異常，類型上都屬于Exception類及其子類。從程序語法角度講是必須進(jìn)行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。

三、Java處理異常機(jī)制

在 Java 應(yīng)用程序中，異常處理機(jī)制為：拋出異常，捕捉異常。

拋出異常：當(dāng)一個方法出現(xiàn)錯誤引發(fā)異常時，方法創(chuàng)建異常對象并交付運(yùn)行時系統(tǒng)，異常對象中包含了異常類型和異常出現(xiàn)時的程序狀態(tài)等異常信息。運(yùn)行時系統(tǒng)負(fù)責(zé)尋找處置異常的代碼并執(zhí)行。

捕獲異常：在方法拋出異常之后，運(yùn)行時系統(tǒng)將轉(zhuǎn)為尋找合適的異常處理器(exception handler)。潛在的異常處理器是異常發(fā)生時依次存留在調(diào)用棧中的方法的集合。當(dāng)異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即為合適 的異常處理器。運(yùn)行時系統(tǒng)從發(fā)生異常的方法開始，依次回查調(diào)用棧中的方法，直至找到含有合適異常處理器的方法并執(zhí)行。當(dāng)運(yùn)行時系統(tǒng)遍歷調(diào)用棧而未找到合適 的異常處理器，則運(yùn)行時系統(tǒng)終止。同時，意味著Java程序的終止。

對于運(yùn)行時異常、錯誤或可查異常，Java技術(shù)所要求的異常處理方式有所不同。

由于運(yùn)行時異常的不可查性，為了更合理、更容易地實(shí)現(xiàn)應(yīng)用程序，Java規(guī)定，運(yùn)行時異常將由Java運(yùn)行時系統(tǒng)自動拋出，允許應(yīng)用程序忽略運(yùn)行時異常。

對于方法運(yùn)行中可能出現(xiàn)的Error，當(dāng)運(yùn)行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因?yàn)?#xff0c;大多數(shù)Error異常屬于永遠(yuǎn)不能被允許發(fā)生的狀況，也屬于合理的應(yīng)用程序不該捕捉的異常。

對于所有的可查異常，Java規(guī)定：一個方法必須捕捉，或者聲明拋出方法之外。也就是說，當(dāng)一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常。

能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由于自身語句所引發(fā)并拋出的異常，也可能是由某個調(diào)用的方法或者Java運(yùn)行時 系統(tǒng)等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所拋出的異常。簡單地說，異常總是先被拋出，后被捕捉的。

任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發(fā)環(huán)境包中代碼，或者Java運(yùn)行時系統(tǒng)。無論是誰，都可以通過Java的throw語句拋出異常。

從方法中拋出的任何異常都必須使用throws子句。

捕捉異常通過try-catch語句或者try-catch-finally語句實(shí)現(xiàn)。

總體來說，Java規(guī)定：對于可查異常必須捕捉、或者聲明拋出。允許忽略不可查的RuntimeException和Error。

3.1?捕獲異常：try、catch 和 finally

3.1.1 try-catch語句

在Java中，異常通過try-catch語句捕獲。其一般語法形式為：

1 try{2 //可能會發(fā)生異常的程序代碼

3 } catch(Type1 id1){4 //捕獲并處置try拋出的異常類型Type1

5 }6 catch(Type2 id2){7 //捕獲并處置try拋出的異常類型Type2

8 }

關(guān)鍵詞try后的一對大括號將一塊可能發(fā)生異常的代碼包起來，稱為監(jiān)控區(qū)域。Java方法在運(yùn)行過程中出現(xiàn)異常，則創(chuàng)建異常對象。將異常拋出監(jiān)控區(qū)域之 外，由Java運(yùn)行時系統(tǒng)試圖尋找匹配的catch子句以捕獲異常。若有匹配的catch子句，則運(yùn)行其異常處理代碼，try-catch語句結(jié)束。

匹配的原則是：如果拋出的異常對象屬于catch子句的異常類，或者屬于該異常類的子類，則認(rèn)為生成的異常對象與catch塊捕獲的異常類型相匹配。

例1? 捕捉throw語句拋出的“除數(shù)為0”異常。

1 /**

2 * 捕捉throw語句拋出的“除數(shù)為0”異常。3 */

4 static voidf1(){5 int a = 6;6 int b = 0;7 //try監(jiān)控區(qū)域

8 try{9 //通過throw語句拋出異常

10 if (b == 0) throw newArithmeticException();11 System.out.println("a/b的值是：" + a /b);12 }13 //catch捕捉異常

14 catch(ArithmeticException e) {15 System.out.println("程序出現(xiàn)異常，變量b不能為0。");16 }17 System.out.println("程序正常結(jié)束。");18 }

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

例1? 在try監(jiān)控區(qū)域通過if語句進(jìn)行判斷，當(dāng)“除數(shù)為0”的錯誤條件成立時引發(fā)ArithmeticException異常，創(chuàng)建 ArithmeticException異常對象，并由throw語句將異常拋給Java運(yùn)行時系統(tǒng)，由系統(tǒng)尋找匹配的異常處理器catch并運(yùn)行相應(yīng)異 常處理代碼，打印輸出“程序出現(xiàn)異常，變量b不能為0。”try-catch語句結(jié)束，繼續(xù)程序流程。

事實(shí)上，“除數(shù)為0”等ArithmeticException，是RuntimException的子類。而運(yùn)行時異常將由運(yùn)行時系統(tǒng)自動拋出，不需要使用throw語句。

例2??捕捉運(yùn)行時系統(tǒng)自動拋出“除數(shù)為0”引發(fā)的ArithmeticException異常。

1 /**

2 * 捕捉運(yùn)行時系統(tǒng)自動拋出“除數(shù)為0”引發(fā)的ArithmeticException異常。3 */

4 static voidf2(){5 int a = 6;6 int b = 0;7 try{8 System.out.println("a/b的值是：" + a /b);9 } catch(ArithmeticException e) {10 System.out.println("程序出現(xiàn)異常，變量b不能為0。");11 }12 System.out.println("程序正常結(jié)束。");13 }

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

例2? 中的語句：System.out.println("a/b的值是：" + a/b);

在運(yùn)行中出現(xiàn)“除數(shù)為0”錯誤，引發(fā)ArithmeticException異常。運(yùn)行時系統(tǒng)創(chuàng)建異常對象并拋出監(jiān)控區(qū)域，轉(zhuǎn)而匹配合適的異常處理器catch，并執(zhí)行相應(yīng)的異常處理代碼。

由于檢查運(yùn)行時異常的代價遠(yuǎn)大于捕捉異常所帶來的益處，運(yùn)行時異常不可查。Java編譯器允許忽略運(yùn)行時異常，一個方法可以既不捕捉，也不聲明拋出運(yùn)行時異常。

例3??不捕捉、也不聲明拋出運(yùn)行時異常。

1 /**

2 * 不捕捉、也不聲明拋出運(yùn)行時異常。3 */

4 static voidf3(){5 inta, b;6 a = 6;7 b = 0; //除數(shù)b 的值為0

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

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

例4? 程序可能存在除數(shù)為0異常和數(shù)組下標(biāo)越界異常。

1 /**

2 * 程序可能存在除數(shù)為0異常和數(shù)組下標(biāo)越界異常。3 */

4 static voidf4(){5 int[] intArray = new int[3];6 try{7 for (int i = 0; i <= intArray.length; i++) {8 intArray[i] =i;9 System.out.println("intArray[" + i + "] = " +intArray[i]);10 System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值: "

11 + intArray[i] % (i - 2));12 }13 } catch(ArrayIndexOutOfBoundsException e) {14 System.out.println("intArray數(shù)組下標(biāo)越界異常。");15 } catch(ArithmeticException e) {16 System.out.println("除數(shù)為0異常。");17 }18 System.out.println("程序正常結(jié)束。");19 }

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

例4? 程序可能會出現(xiàn)除數(shù)為0異常，還可能會出現(xiàn)數(shù)組下標(biāo)越界異常。程序運(yùn)行過程中ArithmeticException異常類型是先行匹配的，因此執(zhí)行相匹配的catch語句：

1 catch(ArithmeticException e){2 System.out.println("除數(shù)為0異常。");3 }

需要注意的是，一旦某個catch捕獲到匹配的異常類型，將進(jìn)入異常處理代碼。一經(jīng)處理結(jié)束，就意味著整個try-catch語句結(jié)束。其他的catch子句不再有匹配和捕獲異常類型的機(jī)會。

Java通過異常類描述異常類型，異常類的層次結(jié)構(gòu)如圖1所示。對于有多個catch子句的異常程序而言，應(yīng)該盡量將捕獲底層異常類的catch子 句放在前面，同時盡量將捕獲相對高層的異常類的catch子句放在后面。否則，捕獲底層異常類的catch子句將可能會被屏蔽。

RuntimeException異常類包括運(yùn)行時各種常見的異常，ArithmeticException類和ArrayIndexOutOfBoundsException類都是它的子類。因此，RuntimeException異常類的catch子句應(yīng)該放在 最后面，否則可能會屏蔽其后的特定異常處理或引起編譯錯誤。

3.1.2 try－catch-finally語句

try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現(xiàn)異常，都應(yīng)當(dāng)執(zhí)行的內(nèi)容。try-catch-finally語句的一般語法形式為：

1 try{2 //可能會發(fā)生異常的程序代碼

3 } catch(Type1 id1) {4 //捕獲并處理try拋出的異常類型Type1

5 } catch(Type2 id2) {6 //捕獲并處理try拋出的異常類型Type2

7 } finally{8 }

例5??帶finally子句的異常處理程序。

1 /**

2 * 帶finally子句的異常處理程序。3 */

4 static voidf5(){5 int i = 0;6 String greetings[] = { " Hello world !", " Hello World !! ",7 " HELLO WORLD !!!"};8 while (i < 4) {9 try{10 //特別注意循環(huán)控制變量i的設(shè)計，避免造成無限循環(huán)

11 System.out.println(greetings[i++]);12 } catch(ArrayIndexOutOfBoundsException e) {13 System.out.println("數(shù)組下標(biāo)越界異常");14 } finally{15 System.out.println("--------------------------");16 }17 }18 }

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

在例5中，請?zhí)貏e注意try子句中語句塊的設(shè)計，如果設(shè)計為如下，將會出現(xiàn)死循環(huán)。如果設(shè)計為：

1 try{2 System.out.println (greetings[i]); i++;3 }

小結(jié)：

try 塊：用于捕獲異常。其后可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。

catch 塊：用于處理try捕獲到的異常。

finally 塊：無論是否捕獲或處理異常，finally塊里的語句都會被執(zhí)行。當(dāng)在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執(zhí)行。在以下4種特殊情況下，finally塊不會被執(zhí)行：

1)在finally語句塊中發(fā)生了異常。

2)在前面的代碼中用了System.exit()退出程序。

3)程序所在的線程死亡。

4)關(guān)閉CPU。

3.1.3?try-catch-finally 規(guī)則(異常處理語句的語法規(guī)則)：

1) ?必須在 try 之后添加 catch 或 finally 塊。try 塊后可同時接 catch 和 finally 塊，但至少有一個塊。

2) 必須遵循塊順序：若代碼同時使用 catch 和 finally 塊，則必須將 catch 塊放在 try 塊之后。

3) catch 塊與相應(yīng)的異常類的類型相關(guān)。

4) 一個 try 塊可能有多個 catch 塊。若如此，則執(zhí)行第一個匹配塊。即Java虛擬機(jī)會把實(shí)際拋出的異常對象依次和各個catch代碼塊聲明的異常類型匹配，如果異常對象為某個異常類型或其子類的實(shí)例，就執(zhí)行這個catch代碼塊，不會再執(zhí)行其他的 catch代碼塊

5) 可嵌套 try-catch-finally 結(jié)構(gòu)。

6) 在 try-catch-finally 結(jié)構(gòu)中，可重新拋出異常。

7) 除了下列情況，總將執(zhí)行 finally 做為結(jié)束：JVM 過早終止(調(diào)用 System.exit(int))；在 finally 塊中拋出一個未處理的異常；計算機(jī)斷電、失火、或遭遇病毒攻擊。

1)當(dāng)try沒有捕獲到異常時：try語句塊中的語句逐一被執(zhí)行，程序?qū)⑻^catch語句塊，執(zhí)行finally語句塊和其后的語句；

2)當(dāng)try捕獲到異常，catch語句塊里沒有處理此異常的情況：當(dāng)try語句塊里的某條語句出現(xiàn)異常時，而沒有處理此異常的catch語句塊時，此異常將會拋給JVM處理，finally語句塊里的語句還是會被執(zhí)行，但finally語句塊后的語句不會被執(zhí)行；

3)當(dāng)try捕獲到異常，catch語句塊里有處理此異常的情況：在try語句塊中是按照順序來執(zhí)行的，當(dāng)執(zhí)行到某一條語句出現(xiàn)異常時，程序?qū)⑻絚atch語句塊，并與catch語句塊逐一匹配，找到與之對應(yīng)的處理程序，其他的catch語句塊將不會被執(zhí)行，而try語句塊中，出現(xiàn)異常之后的語句也不會被執(zhí)行，catch語句塊執(zhí)行完后，執(zhí)行finally語句塊里的語句，最后執(zhí)行finally語句塊后的語句；

圖示try、catch、finally語句塊的執(zhí)行：

3.2 拋出異常

任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發(fā)環(huán)境包中代碼，或者Java運(yùn)行時系統(tǒng)。無論是誰，都可以通過Java的throw語句拋出異常。從方法中拋出的任何異常都必須使用throws子句。

3.2.1 throws拋出異常

如果一個方法可能會出現(xiàn)異常，但沒有能力處理這種異常，可以在方法聲明處用throws子句來聲明拋出異常。例如汽車在運(yùn)行時可能會出現(xiàn)故障，汽車本身沒辦法處理這個故障，那就讓開車的人來處理。

throws語句用在方法定義時聲明該方法要拋出的異常類型，如果拋出的是Exception異常類型，則該方法被聲明為拋出所有的異常。多個異常可使用逗號分割。throws語句的語法格式為：

1 methodname throwsException1,Exception2,..,ExceptionN {2 }

方法名后的throws Exception1,Exception2,...,ExceptionN 為聲明要拋出的異常列表。當(dāng)方法拋出異常列表的異常時，方法將不對這些類型及其子類類型的異常作處理，而拋向調(diào)用該方法的方法，由他去處理。例如：

1 packageexception;2

3 /**

4 *@authorzsh5 * @company wlgzs6 * @create 2019-03-01 21:307 * @Describe 異常處理測試8 */

9 public classMain3 {10

11 static void pop() throwsNegativeArraySizeException {12 //定義方法并拋出NegativeArraySizeException異常

13 int[] arr = new int[-3]; //創(chuàng)建數(shù)組

14 }15

16 public static voidmain(String[] args) {17 try { //try語句處理異常信息

18 pop(); //調(diào)用pop()方法

19 } catch(NegativeArraySizeException e) {20 System.out.println("pop()方法拋出的異常");//輸出異常信息

21 }22 }23 }

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

使用throws關(guān)鍵字將異常拋給調(diào)用者后，如果調(diào)用者不想處理該異常，可以繼續(xù)向上拋出，但最終要有能夠處理該異常的調(diào)用者。pop方法沒有處理異常NegativeArraySizeException，而是由main函數(shù)來處理。

Throws拋出異常的規(guī)則：

1) 如果是不可查異常(unchecked exception)，即Error、RuntimeException或它們的子類，那么可以不使用throws關(guān)鍵字來聲明要拋出的異常，編譯仍能順利通過，但在運(yùn)行時會被系統(tǒng)拋出。

2)必須聲明方法可拋出的任何可查異常(checked exception)。即如果一個方法可能出現(xiàn)受可查異常，要么用try-catch語句捕獲，要么用throws子句聲明將它拋出，否則會導(dǎo)致編譯錯誤

3)僅當(dāng)拋出了異常，該方法的調(diào)用者才必須處理或者重新拋出該異常。當(dāng)方法的調(diào)用者無力處理該異常的時候，應(yīng)該繼續(xù)拋出，而不是囫圇吞棗。

4)調(diào)用方法必須遵循任何可查異常的處理和聲明規(guī)則。若覆蓋一個方法，則不能聲明與覆蓋方法不同的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類。

例如：

1 //合法

2 void method1() throwsIOException{}3

4 //編譯錯誤，必須捕獲或聲明拋出IOException

5 voidmethod2(){6 method1();7 }8

9 //合法，聲明拋出IOException

10 void method3()throwsIOException {11 method1();12 }13

14 //合法，聲明拋出Exception，IOException是Exception的子類

15 void method4()throwsException {16 method1();17 }18

19 //合法，捕獲IOException

20 voidmethod5(){21 try{22 method1();23 }catch(IOException e){ }24 }25

26 //編譯錯誤，必須捕獲或聲明拋出Exception

27 voidmethod6(){28 try{29 method1();30 }catch(IOException e){throw newException();}31 }32

33 //合法，聲明拋出Exception

34 void method7() throwsException{35 try{36 method1();37 }catch(IOException e){throw newException();}38 }

判斷一個方法可能會出現(xiàn)異常的依據(jù)如下：

1)方法中有throw語句。例如，以上method7()方法的catch代碼塊有throw語句。　　2)調(diào)用了其他方法，其他方法用throws子句聲明拋出某種異常。例如，method3()方法調(diào)用了method1()方法，method1()方法聲明拋出IOException，因此，在method3()方法中可能會出現(xiàn)IOException。

3.2.2?使用throw拋出異常

throw總是出現(xiàn)在函數(shù)體中，用來拋出一個Throwable類型的異常。程序會在throw語句后立即終止，它后面的語句執(zhí)行不到，然后在包含它的所有try塊中(可能在上層調(diào)用函數(shù)中)從里向外尋找含有與其匹配的catch子句的try塊。

我們知道，異常是異常類的實(shí)例對象，我們可以創(chuàng)建異常類的實(shí)例對象通過throw語句拋出。該語句的語法格式為：

throw new exceptionname;

例如拋出一個IOException類的異常對象：

throw new IOException;

要注意的是，throw 拋出的只能夠是可拋出類Throwable 或者其子類的實(shí)例對象。下面的操作是錯誤的：

throw new String("exception");

這是因?yàn)镾tring 不是Throwable 類的子類。

如果拋出了檢查異常，則還應(yīng)該在方法頭部聲明方法可能拋出的異常類型。該方法的調(diào)用者也必須檢查處理拋出的異常。

如果所有方法都層層上拋獲取的異常，最終JVM會進(jìn)行處理，處理也很簡單，就是打印異常消息和堆棧信息。如果拋出的是Error或RuntimeException，則該方法的調(diào)用者可選擇處理該異常。

1 packageexception;2

3 /**

4 *@authorzsh5 * @company wlgzs6 * @create 2019-03-01 21:427 * @Describe 使用throw拋出異常8 */

9 public classMain4 {10

11 static int quotient(int x, int y) throws MyException { //定義方法拋出異常

12 if (y < 0) { //判斷參數(shù)是否小于0

13 throw new MyException("除數(shù)不能是負(fù)數(shù)"); //異常信息

14 }15 return x/y; //返回值

16 }17 public static void main(String args[]) { //主方法

18 int a =3;19 int b = -1;20 try { //try語句包含可能發(fā)生異常的語句

21 int result = quotient(a, b); //調(diào)用方法quotient()

22 } catch (MyException e) { //處理自定義異常

23 System.out.println(e.getMessage()); //輸出異常信息

24 } catch (ArithmeticException e) { //處理ArithmeticException異常

25 System.out.println("除數(shù)不能為0"); //輸出提示信息

26 } catch (Exception e) { //處理其他異常

27 System.out.println("程序發(fā)生了其他的異常"); //輸出提示信息

28 }29 }30 }31

32 class MyException extends Exception { //創(chuàng)建自定義異常類

33 String message; //定義String類型變量

34 public MyException(String ErrorMessagr) { //父類方法

35 message =ErrorMessagr;36 }37

38 public String getMessage() { //覆蓋getMessage()方法

39 returnmessage;40 }41 }

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

3.3 異常鏈

1) 如果調(diào)用quotient(3,-1)，將發(fā)生MyException異常，程序調(diào)轉(zhuǎn)到catch (MyException e)代碼塊中執(zhí)行；

2) 如果調(diào)用quotient(5,0)，將會因“除數(shù)為0”錯誤引發(fā)ArithmeticException異常，屬于運(yùn)行時異常類，由Java運(yùn)行時系統(tǒng)自動拋出。quotient()方法沒有捕捉ArithmeticException異常，Java運(yùn)行時系統(tǒng)將沿方法調(diào)用棧查到main方法，將拋出的異常上傳至quotient()方法的調(diào)用者：

int result = quotient(a, b); // 調(diào)用方法quotient()

由于該語句在try監(jiān)控區(qū)域內(nèi)，因此傳回的“除數(shù)為0”的ArithmeticException異常由Java運(yùn)行時系統(tǒng)拋出，并匹配catch子句：

catch (ArithmeticException e) { // 處理ArithmeticException異常

System.out.println("除數(shù)不能為0"); // 輸出提示信息

}

處理結(jié)果是輸出“除數(shù)不能為0”。Java這種向上傳遞異常信息的處理機(jī)制，形成異常鏈。

Java方法拋出的可查異常將依據(jù)調(diào)用棧、沿著方法調(diào)用的層次結(jié)構(gòu)一直傳遞到具備處理能力的調(diào)用方法，最高層次到main方法為止。如果異常傳遞到main方法，而main不具備處理能力，也沒有通過throws聲明拋出該異常，將可能出現(xiàn)編譯錯誤。

3)如還有其他異常發(fā)生，將使用catch (Exception e)捕捉異常。由于Exception是所有異常類的父類，如果將catch (Exception e)代碼塊放在其他兩個代碼塊的前面，后面的代碼塊將永遠(yuǎn)得不到執(zhí)行，就沒有什么意義了，所以catch語句的順序不可掉換。

3.4?Throwable類中的常用方法

注意：catch關(guān)鍵字后面括號中的Exception類型的參數(shù)e。Exception就是try代碼塊傳遞給catch代碼塊的變量類型，e就是變量名。catch代碼塊中語句"e.getMessage();"用于輸出錯誤性質(zhì)。通常異常處理常用3個函數(shù)來獲取異常的有關(guān)信息:

getCause()：返回拋出異常的原因。如果 cause 不存在或未知，則返回 null。

getMeage()：返回異常的消息信息。

printStackTrace()：對象的堆棧跟蹤輸出至錯誤輸出流，作為字段 System.err 的值。

有時為了簡單會忽略掉catch語句后的代碼，這樣try-catch語句就成了一種擺設(shè)，一旦程序在運(yùn)行過程中出現(xiàn)了異常，就會忽略處理異常，而錯誤發(fā)生的原因很難查找。

四、Java常見異常

在Java中提供了一些異常用來描述經(jīng)常發(fā)生的錯誤，對于這些異常，有的需要程序員進(jìn)行捕獲處理或聲明拋出，有的是由Java虛擬機(jī)自動進(jìn)行捕獲處理。Java中常見的異常類:

4.1?runtimeException子類:

1、java.lang.ArrayIndexOutOfBoundsException

數(shù)組索引越界異常。當(dāng)對數(shù)組的索引值為負(fù)數(shù)或大于等于數(shù)組大小時拋出。2、java.lang.ArithmeticException

算術(shù)條件異常。譬如：整數(shù)除零等。3、java.lang.NullPointerException

空指針異常。當(dāng)應(yīng)用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調(diào)用null對象的實(shí)例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等4、java.lang.ClassNotFoundException

找不到類異常。當(dāng)應(yīng)用試圖根據(jù)字符串形式的類名構(gòu)造類，而在遍歷CLASSPAH之后找不到對應(yīng)名稱的class文件時，拋出該異常。5、java.lang.NegativeArraySizeException

數(shù)組長度為負(fù)異常6、java.lang.ArrayStoreException

數(shù)組中包含不兼容的值拋出的異常7、java.lang.SecurityException

安全性異常8、java.lang.IllegalArgumentException

非法參數(shù)異常

4.2?IOException

IOException：操作輸入流和輸出流時可能出現(xiàn)的異常。

EOFException：文件已結(jié)束異常

FileNotFoundException：文件未找到異常

4.3 其他

ClassCastException ? ?類型轉(zhuǎn)換異常類

ArrayStoreException ?數(shù)組中包含不兼容的值拋出的異常

SQLException ? 操作數(shù)據(jù)庫異常類

NoSuchFieldException ? 字段未找到異常

NoSuchMethodException ? 方法未找到拋出的異常

NumberFormatException ? ?字符串轉(zhuǎn)換為數(shù)字拋出的異常

StringIndexOutOfBoundsException 字符串索引超出范圍拋出的異常

IllegalAccessException ?不允許訪問某類異常

InstantiationException ?當(dāng)應(yīng)用程序試圖使用Class類中的newInstance()方法創(chuàng)建一個類的實(shí)例，而指定的類對象無法被實(shí)例化時，拋出該異常

五、自定義異常

使用Java內(nèi)置的異常類可以描述在編程時出現(xiàn)的大部分異常情況。除此之外，用戶還可以自定義異常。用戶自定義異常類，只需繼承Exception類即可。

在程序中使用自定義異常類，大體可分為以下幾個步驟。

(1)創(chuàng)建自定義異常類。

(2)在方法中通過throw關(guān)鍵字拋出異常對象。

(3)如果在當(dāng)前拋出異常的方法中處理異常，可以使用try-catch語句捕獲并處理；否則在方法的聲明處通過throws關(guān)鍵字指明要拋出給方法調(diào)用者的異常，繼續(xù)進(jìn)行下一步操作。

(4)在出現(xiàn)異常方法的調(diào)用者中捕獲并處理異常。

在上面的“使用throw拋出異常”例子已經(jīng)提到了。

總結(jié)

以上是生活随笔為你收集整理的java 异常机制_深入理解Java异常处理机制的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。