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

package Test; public class TestException { public TestException() { }boolean testEx() throws Exception { boolean ret = true; try { ret = testEx1(); } catch (Exception e) { System.out.println("testEx, catch exception"); ret = false; throw e; } finally { System.out.println("testEx, finally; return value=" + ret); return ret; } }boolean testEx1() throws Exception { boolean ret = true; try { ret = testEx2(); if (!ret) { return false; } System.out.println("testEx1, at the end of try"); return ret; } catch (Exception e) { System.out.println("testEx1, catch exception"); ret = false; throw e; } finally { System.out.println("testEx1, finally; return value=" + ret); return ret; } }boolean testEx2() throws Exception { boolean ret = true; try { int b = 12; int c; for (int i = 2; i >= -2; i--) { c = b / i; System.out.println("i=" + i); } return true; } catch (Exception e) { System.out.println("testEx2, catch exception"); ret = false; throw e; } finally { System.out.println("testEx2, finally; return value=" + ret); return ret; } }public static void main(String[] args) { TestException testException1 = new TestException(); try { testException1.testEx(); } catch (Exception e) { e.printStackTrace(); } } }

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

i=2i=1testEx2, catch exceptiontestEx2, finally; return value=falsetestEx1, catch exceptiontestEx1, finally; return value=falsetestEx, catch exceptiontestEx, finally; return value=false

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

i=2i=1testEx2, catch exceptiontestEx2, finally; return value=falsetestEx1, finally; return value=falsetestEx, finally; return value=false

注意說(shuō)明：

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

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

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

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

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

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

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

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

Exception（異常）:是程序本身可以處理的異常。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3.1 捕獲異常：try、catch 和 finally

1.try-catch語(yǔ)句

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

try { // 可能會(huì)發(fā)生異常的程序代碼 } catch (Type1 id1){ // 捕獲并處置try拋出的異常類型Type1 } catch (Type2 id2){ //捕獲并處置try拋出的異常類型Type2 }

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

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

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

public class TestException { public static void main(String[] args) { int a = 6; int b = 0; try { // try監(jiān)控區(qū)域 if (b == 0) throw new ArithmeticException(); // 通過(guò)throw語(yǔ)句拋出異常 System.out.println("a/b的值是：" + a / b); } catch (ArithmeticException e) { // catch捕捉異常 System.out.println("程序出現(xiàn)異常，變量b不能為0。"); } System.out.println("程序正常結(jié)束。"); } }

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

程序出現(xiàn)異常，變量b不能為0。

程序正常結(jié)束。

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

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

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

public static void main(String[] args) { int a = 6; int b = 0; try { System.out.println("a/b的值是：" + a / b); } catch (ArithmeticException e) { System.out.println("程序出現(xiàn)異常，變量b不能為0。"); } System.out.println("程序正常結(jié)束。"); } }

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

程序出現(xiàn)異常，變量b不能為0。

程序正常結(jié)束。

例2 中的語(yǔ)句：

System.out.println(“a/b的值是：” + a/b);

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

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

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

public class TestException { public static void main(String[] args) { int a, b; a = 6; b = 0; // 除數(shù)b 的值為0 System.out.println(a / b); } }

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

Exception in thread “main” java.lang.ArithmeticException: / by zeroat Test.TestException.main(TestException.java:8)

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

public class TestException { public static void main(String[] args) { int[] intArray = new int[3]; try { for (int i = 0; i <= intArray.length; i++) { intArray[i] = i; System.out.println("intArray[" + i + "] = " + intArray[i]); System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值: " + intArray[i] % (i - 2)); } } catch (ArrayIndexOutOfBoundsException e) { System.out.println("intArray數(shù)組下標(biāo)越界異常。"); } catch (ArithmeticException e) { System.out.println("除數(shù)為0異常。"); } System.out.println("程序正常結(jié)束。"); } }

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

intArray[0] = 0

intArray[0]模 -2的值: 0

intArray[1] = 1

intArray[1]模 -1的值: 0

intArray[2] = 2

除數(shù)為0異常。

程序正常結(jié)束。

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

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

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

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

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

2. try－catch-finally語(yǔ)句

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

try { // 可能會(huì)發(fā)生異常的程序代碼 } catch (Type1 id1) { // 捕獲并處理try拋出的異常類型Type1 } catch (Type2 id2) { // 捕獲并處理try拋出的異常類型Type2 } finally { // 無(wú)論是否發(fā)生異常，都將執(zhí)行的語(yǔ)句塊 }

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

public class TestException { public static void main(String args[]) { int i = 0; String greetings[] = { " Hello world !", " Hello World !! ", " HELLO WORLD !!!" }; while (i < 4) { try { // 特別注意循環(huán)控制變量i的設(shè)計(jì)，避免造成無(wú)限循環(huán) System.out.println(greetings[i++]); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("數(shù)組下標(biāo)越界異常"); } finally { System.out.println("--------------------------"); } } } }

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

Hello world !

————————–

Hello World !!

————————–

HELLO WORLD !!!

————————–

數(shù)組下標(biāo)越界異常

————————–

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

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

小結(jié)：

try 塊：用于捕獲異常。其后可接零個(gè)或多個(gè)catch塊，如果沒(méi)有catch塊，則必須跟一個(gè)finally塊。catch 塊：用于處理try捕獲到的異常。finally 塊：無(wú)論是否捕獲或處理異常，finally塊里的語(yǔ)句都會(huì)被執(zhí)行。當(dāng)在try塊或catch塊中遇到return語(yǔ)句時(shí)，finally語(yǔ)句塊將在方法返回之前被執(zhí)行。在以下4種特殊情況下，finally塊不會(huì)被執(zhí)行：1）在finally語(yǔ)句塊中發(fā)生了異常。2）在前面的代碼中用了System.exit()退出程序。3）程序所在的線程死亡。4）關(guān)閉CPU。

3. try-catch-finally 規(guī)則(異常處理語(yǔ)句的語(yǔ)法規(guī)則）：

1) 必須在 try 之后添加 catch 或 finally 塊。try 塊后可同時(shí)接 catch 和 finally 塊，但至少有一個(gè)塊。2) 必須遵循塊順序：若代碼同時(shí)使用 catch 和 finally 塊，則必須將 catch 塊放在 try 塊之后。3) catch 塊與相應(yīng)的異常類的類型相關(guān)。4) 一個(gè) try 塊可能有多個(gè) catch 塊。若如此，則執(zhí)行第一個(gè)匹配塊。即Java虛擬機(jī)會(huì)把實(shí)際拋出的異常對(duì)象依次和各個(gè)catch代碼塊聲明的異常類型匹配，如果異常對(duì)象為某個(gè)異常類型或其子類的實(shí)例，就執(zhí)行這個(gè)catch代碼塊，不會(huì)再執(zhí)行其他的 catch代碼塊5) 可嵌套 try-catch-finally 結(jié)構(gòu)。6) 在 try-catch-finally 結(jié)構(gòu)中，可重新拋出異常。7) 除了下列情況，總將執(zhí)行 finally 做為結(jié)束：JVM 過(guò)早終止（調(diào)用 System.exit(int)）；在 finally 塊中拋出一個(gè)未處理的異常；計(jì)算機(jī)斷電、失火、或遭遇病毒攻擊。

4. try、catch、finally語(yǔ)句塊的執(zhí)行順序:

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

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

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

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

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

3.2 拋出異常

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

1. throws拋出異常

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

throws語(yǔ)句用在方法定義時(shí)聲明該方法要拋出的異常類型，如果拋出的是Exception異常類型，則該方法被聲明為拋出所有的異常。多個(gè)異常可使用逗號(hào)分割。throws語(yǔ)句的語(yǔ)法格式為：

methodname throws Exception1,Exception2,..,ExceptionN { }

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

import java.lang.Exception; public class TestException { static void pop() throws NegativeArraySizeException { // 定義方法并拋出NegativeArraySizeException異常 int[] arr = new int[-3]; // 創(chuàng)建數(shù)組 }public static void main(String[] args) { // 主方法 try { // try語(yǔ)句處理異常信息 pop(); // 調(diào)用pop()方法 } catch (NegativeArraySizeException e) { System.out.println("pop()方法拋出的異常");// 輸出異常信息 } } }

使用throws關(guān)鍵字將異常拋給調(diào)用者后，如果調(diào)用者不想處理該異常，可以繼續(xù)向上拋出，但最終要有能夠處理該異常的調(diào)用者。

pop方法沒(méi)有處理異常NegativeArraySizeException，而是由main函數(shù)來(lái)處理。

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

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

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

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

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

例如：

void method1() throws IOException{} //合法 //編譯錯(cuò)誤，必須捕獲或聲明拋出IOException void method2(){ method1(); } //合法，聲明拋出IOException void method3()throws IOException { method1(); } //合法，聲明拋出Exception，IOException是Exception的子類 void method4()throws Exception { method1(); } //合法，捕獲IOException void method5(){ try{method1(); }catch(IOException e){…} } //編譯錯(cuò)誤，必須捕獲或聲明拋出Exception void method6(){ try{method1(); }catch(IOException e){throw new Exception();} } //合法，聲明拋出Exception void method7()throws Exception{ try{ method1(); }catch(IOException e){throw new Exception();} }

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

1）方法中有throw語(yǔ)句。例如，以上method7()方法的catch代碼塊有throw語(yǔ)句。

2）調(diào)用了其他方法，其他方法用throws子句聲明拋出某種異常。例如，method3()方法調(diào)用了method1()方法，method1()方法聲明拋出IOException，因此，在method3()方法中可能會(huì)出現(xiàn)IOException。

2. 使用throw拋出異常

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

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

throw new exceptionname;

例如拋出一個(gè)IOException類的異常對(duì)象：

throw new IOException;

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

throw new String(“exception”);

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

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

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

package Test; import java.lang.Exception; public class TestException { static int quotient(int x, int y) throws MyException { // 定義方法拋出異常 if (y < 0) { // 判斷參數(shù)是否小于0 throw new MyException("除數(shù)不能是負(fù)數(shù)"); // 異常信息 } return x/y; // 返回值 } public static void main(String args[]) { // 主方法 int a =3; int b =0; try { // try語(yǔ)句包含可能發(fā)生異常的語(yǔ)句 int result = quotient(a, b); // 調(diào)用方法quotient() } catch (MyException e) { // 處理自定義異常 System.out.println(e.getMessage()); // 輸出異常信息 } catch (ArithmeticException e) { // 處理ArithmeticException異常 System.out.println("除數(shù)不能為0"); // 輸出提示信息 } catch (Exception e) { // 處理其他異常 System.out.println("程序發(fā)生了其他的異常"); // 輸出提示信息 } } } class MyException extends Exception { // 創(chuàng)建自定義異常類 String message; // 定義String類型變量 public MyException(String ErrorMessagr) { // 父類方法 message = ErrorMessagr; }public String getMessage() { // 覆蓋getMessage()方法 return message; } }

3.3 異常鏈

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

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

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

由于該語(yǔ)句在try監(jiān)控區(qū)域內(nèi)，因此傳回的“除數(shù)為0”的ArithmeticException異常由Java運(yùn)行時(shí)系統(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不具備處理能力，也沒(méi)有通過(guò)throws聲明拋出該異常，將可能出現(xiàn)編譯錯(cuò)誤。

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

3.4 Throwable類中的常用方法

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

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

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

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

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

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

1. runtimeException子類:

1、 java.lang.ArrayIndexOutOfBoundsException

數(shù)組索引越界異常。當(dāng)對(duì)數(shù)組的索引值為負(fù)數(shù)或大于等于數(shù)組大小時(shí)拋出。

2、java.lang.ArithmeticException

算術(shù)條件異常。譬如：整數(shù)除零等。

3、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等等

4、java.lang.ClassNotFoundException

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

5、java.lang.NegativeArraySizeException 數(shù)組長(zhǎng)度為負(fù)異常

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

7、java.lang.SecurityException 安全性異常

8、java.lang.IllegalArgumentException 非法參數(shù)異常

2.IOException

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

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

FileNotFoundException 文件未找到異常

3. 其他

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

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

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

NoSuchFieldException 字段未找到異常

NoSuchMethodException 方法未找到拋出的異常

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

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

IllegalAccessException 不允許訪問(wèn)某類異常

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

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

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

（1）創(chuàng)建自定義異常類。（2）在方法中通過(guò)throw關(guān)鍵字拋出異常對(duì)象。（3）如果在當(dāng)前拋出異常的方法中處理異常，可以使用try-catch語(yǔ)句捕獲并處理；否則在方法的聲明處通過(guò)throws關(guān)鍵字指明要拋出給方法調(diào)用者的異常，繼續(xù)進(jìn)行下一步操作。（4）在出現(xiàn)異常方法的調(diào)用者中捕獲并處理異常。

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