一、引言

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

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=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? ? ? ?如果你的答案真的如上面所說，那么你錯啦。^_^，那就建議你仔細看一看這篇文章或者拿上面的代碼按各種不同的情況修改、執行、測試，你會發現有很多事情不是原來想象中的那么簡單的。正確答案是：
i=2 i=1 testEx2, catch exception testEx2, finally; return value=false testEx1, finally; return value=false testEx, finally; return value=false

注意說明：finally語句塊不應該出現 應該出現return。上面的return ret最好是其他語句來處理相關邏輯。

二、JAVA異常

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

Java異常類層次結構圖：

? ? ? ?在 Java 中，所有的異常都有一個共同的祖先 Throwable（可拋出）。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。

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

? ? ? ?Error（錯誤）：是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。這些錯誤表示故障發生于虛擬機自身、或者發生在虛擬機試圖執行應用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應用程序的控制和處理能力之 外，而且絕大多數是程序運行時不允許出現的狀況。對于設計合理的應用程序來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。

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

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

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

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

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

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

? ? ? ?不可查異常（編譯器不要求強制處置的異常）：包括運行時異常（RuntimeException與其子類）和錯誤（Error）。

? ? ? ?Exception 這種異常分兩大類：運行時異常和非運行時異常（編譯異常）。程序中應當盡可能去處理這些異常。

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

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

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

三、處理異常機制

? ? ? ?在 Java 應用程序中，異常處理機制為：拋出異常，捕捉異常。

? ? ? ?拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象并交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼并執行。

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

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

? ? ? ?由于運行時異常的不可查性，為了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程序忽略運行時異常。

? ? ? ?對于方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因為，大多數Error異常屬于永遠不能被允許發生的狀況，也屬于合理的應用程序不該捕捉的異常。

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

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

? ? ? ?任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。

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

? ? ? ?捕捉異常通過try-catch語句或者try-catch-finally語句實現。

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

1、捕獲異常

（1）try-catch語句

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

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

? ? ? ?關鍵詞try后的一對大括號將一塊可能發生異常的代碼包起來，稱為監控區域。Java方法在運行過程中出現異常，則創建異常對象。將異常拋出監控區域之 外，由Java運行時系統試圖尋找匹配的catch子句以捕獲異常。若有匹配的catch子句，則運行其異常處理代碼，try-catch語句結束。

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

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

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

程序出現異常，變量b不能為0。 程序正常結束。

? ? ? ?例1? 在try監控區域通過if語句進行判斷，當“除數為0”的錯誤條件成立時引發ArithmeticException異常，創建 ArithmeticException異常對象，并由throw語句將異常拋給Java運行時系統，由系統尋找匹配的異常處理器catch并運行相應異 常處理代碼，打印輸出“程序出現異常，變量b不能為0。”try-catch語句結束，繼續程序流程。

? ? ? ?事實上，“除數為0”等ArithmeticException，是RuntimException的子類。而運行時異常將由運行時系統自動拋出，不需要使用throw語句。

例2 ? 捕捉運行時系統自動拋出“除數為0”引發的ArithmeticException異常。

public class TestException {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("程序出現異常，變量b不能為0。"); } System.out.println("程序正常結束。"); } }運行結果：

程序出現異常，變量b不能為0。 程序正常結束。

例2? 中的語句：

? ? ? ?System.out.println("a/b的值是：" + a/b);

? ? ? ?在運行中出現“除數為0”錯誤，引發ArithmeticException異常。運行時系統創建異常對象并拋出監控區域，轉而匹配合適的異常處理器catch，并執行相應的異常處理代碼。

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

例3??不捕捉、也不聲明拋出運行時異常。

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

Exception in thread "main" java.lang.ArithmeticException: / by zero at Test.TestException.main(TestException.java:8) 例4 ? 程序可能存在除數為0異常和數組下標越界異常。
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數組下標越界異常。"); } catch (ArithmeticException e) { System.out.println("除數為0異常。"); } System.out.println("程序正常結束。"); } } 運行結果：

intArray[0] = 0 intArray[0]模 -2的值: 0 intArray[1] = 1 intArray[1]模 -1的值: 0 intArray[2] = 2 除數為0異常。 程序正常結束。? ? ? ?例4? 程序可能會出現除數為0異常，還可能會出現數組下標越界異常。程序運行過程中ArithmeticException異常類型是先行匹配的，因此執行相匹配的catch語句：
catch (ArithmeticException e){ System.out.println("除數為0異常。"); }

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

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

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

（2）try-catch-finally語句

? ? ? ?try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現異常，都應當執行的內容。try-catch-finally語句的一般語法形式為：

try { // 可能會發生異常的程序代碼 } catch (Type1 id1) { // 捕獲并處理try拋出的異常類型Type1 } catch (Type2 id2) { // 捕獲并處理try拋出的異常類型Type2 } finally { // 無論是否發生異常，都將執行的語句塊 } 例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 { // 特別注意循環控制變量i的設計，避免造成無限循環 System.out.println(greetings[i++]); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("數組下標越界異常"); } finally { System.out.println("--------------------------"); } } } } 運行結果：

Hello world ! -------------------------- Hello World !! -------------------------- HELLO WORLD !!! -------------------------- 數組下標越界異常 --------------------------? ? ? ?在例5中，請特別注意try子句中語句塊的設計，如果設計為如下，將會出現死循環。如果設計為：
try { System.out.println (greetings[i]); i++; } 小結：
try 塊：用于捕獲異常。其后可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。
catch 塊：用于處理try捕獲到的異常。
finally 塊：無論是否捕獲或處理異常，finally塊里的語句都會被執行。 當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執行。在以下4種特殊情況下，finally塊不會被執行：
1）在finally語句塊中發生了異常。
2）在前面的代碼中用了System.exit()退出程序。
3）程序所在的線程死亡。
4）關閉CPU。

（3）try-catch-finally 規則（異常處理語句的語法規則）

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

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

（4）try、catch、finally語句塊的執行順序

1）當try沒有捕獲到異常時：try語句塊中的語句逐一被執行，程序將跳過catch語句塊，執行finally語句塊和其后的語句；

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

3）當try捕獲到異常，catch語句塊里有處理此異常的情況：在try語句塊中是按照順序來執行的，當執行到某一條語句出現異常時，程序將跳到catch語句塊，并與catch語句塊逐一匹配，找到與之對應的處理程序，其他的catch語句塊將不會被執行，而try語句塊中，出現異常之后的語句也不會被執行，catch語句塊執行完后，執行finally語句塊里的語句，最后執行finally語句塊后的語句；

圖示try、catch、finally語句塊的執行：

2、拋出異常

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

（1）throws拋出異常

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

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

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

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

? ? ? ?使用throws關鍵字將異常拋給調用者后，如果調用者不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的調用者。

? ? ? ?pop方法沒有處理異常NegativeArraySizeException，而是由main函數來處理。

Throws拋出異常的規則：

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

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

? ? 3）僅當拋出了異常，該方法的調用者才必須處理或者重新拋出該異常。當方法的調用者無力處理該異常的時候，應該繼續拋出，而不是囫圇吞棗。

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

例如：

void method1() throws IOException{} //合法 //編譯錯誤，必須捕獲或聲明拋出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){…} } //編譯錯誤，必須捕獲或聲明拋出Exception void method6(){ try{ method1(); }catch(IOException e){throw new Exception();} } //合法，聲明拋出Exception void method7()throws Exception{ try{ method1(); }catch(IOException e){throw new Exception();} } 判斷一個方法可能會出現異常的依據如下：

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

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

（2）使用throw拋出異常
? ? ? ?throw總是出現在函數體中，用來拋出一個Throwable類型的異常。程序會在throw語句后立即終止，它后面的語句執行不到，然后在包含它的所有try塊中（可能在上層調用函數中）從里向外尋找含有與其匹配的catch子句的try塊。

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

? ? ? ?throw new exceptionname;

? ? ? ?例如拋出一個IOException類的異常對象：
? ? ? ?throw new IOException;
? ? ? ?要注意的是，throw 拋出的只能夠是可拋出類Throwable 或者其子類的實例對象。下面的操作是錯誤的：

? ? ? ?throw new String("exception");

? ? ? ?這是因為String 不是Throwable 類的子類。

? ? ? ?如果拋出了檢查異常，則還應該在方法頭部聲明方法可能拋出的異常類型。該方法的調用者也必須檢查處理拋出的異常。

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

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

? ? ? ?1）如果調用quotient(3,-1)，將發生MyException異常，程序調轉到catch (MyException e)代碼塊中執行；

? ? ? ?如果調用quotient(5,0)，將會因“除數為0”錯誤引發ArithmeticException異常，屬于運行時異常類，由Java運行時系統自動拋出。quotient（）方法沒有捕捉ArithmeticException異常，Java運行時系統將沿方法調用棧查到main方法，將拋出的異常上傳至quotient（）方法的調用者：

? ? ? ?int result = quotient(a, b); // 調用方法quotient()

? ? ? ?由于該語句在try監控區域內，因此傳回的“除數為0”的ArithmeticException異常由Java運行時系統拋出，并匹配catch子句：

catch (ArithmeticException e) { // 處理ArithmeticException異常System.out.println("除數不能為0"); // 輸出提示信息 }

? ? ? ?處理結果是輸出“除數不能為0”。Java這種向上傳遞異常信息的處理機制，形成異常鏈。

? ? ? ?Java方法拋出的可查異常將依據調用棧、沿著方法調用的層次結構一直傳遞到具備處理能力的調用方法，最高層次到main方法為止。如果異常傳遞到main方法，而main不具備處理能力，也沒有通過throws聲明拋出該異常，將可能出現編譯錯誤。

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

（4）Throwable類中的常用方法

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

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

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

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

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

四、Java常見異常
? ? ? ?在Java中提供了一些異常用來描述經常發生的錯誤，對于這些異常，有的需要程序員進行捕獲處理或聲明拋出，有的是由Java虛擬機自動進行捕獲處理。Java中常見的異常類：

1、runtimeException子類

? ?java.lang.ArrayIndexOutOfBoundsException：數組索引越界異常。當對數組的索引值為負數或大于等于數組大小時拋出。

? ?java.lang.ArithmeticException：算術條件異常。譬如：整數除零等。

? ?java.lang.NullPointerException：空指針異常。當應用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等

? ?java.lang.ClassNotFoundException：找不到類異常。當應用試圖根據字符串形式的類名構造類，而在遍歷CLASSPAH之后找不到對應名稱的class文件時，拋出該異常。

? ?java.lang.NegativeArraySizeException：數組長度為負異常

? ?java.lang.ArrayStoreException：數組中包含不兼容的值拋出的異常

? ?java.lang.SecurityException：安全性異常

? ?java.lang.IllegalArgumentException：非法參數異常

2、IOException

? ? java.io.IOException：操作輸入流和輸出流時可能出現的異常。

? ? java.io.EOFException：文件已結束異常

? ? java.io.FileNotFoundException：文件未找到異常

3、其他

? ? java.lang.ClassCastException：類型轉換異常類

? ? java.sql.SQLException：操作數據庫異常類

? ? java.lang.NoSuchFieldException：字段未找到異常

? ? java.lang.NoSuchMethodException：方法未找到拋出的異常

? ? java.lang.NumberFormatException：字符串轉換為數字拋出的異常

? ? java.lang.StringIndexOutOfBoundsException：字符串索引超出范圍拋出的異常

? ? java.lang.IllegalAccessException：不允許訪問某類異常

? ? java.lang.InstantiationException：當應用程序試圖使用Class類中的newInstance()方法創建一個類的實例，而指定的類對象無法被實例化時，拋出該異常

? ??java.lang.CloneNotSupportedException：不支持克隆異常。當沒有實現Cloneable接口或者不支持克隆方法時,調用其clone()方法則拋出該異常。

? ??java.lang.EnumConstantNotPresentException：枚舉常量不存在異常。當應用試圖通過名稱和枚舉類型訪問一個枚舉對象，但該枚舉對象并不包含常量時，拋出該異常。

? ??java.lang.IllegalMonitorStateException：違法的監控狀態異常。當某個線程試圖等待一個自己并不擁有的對象（O）的監控器或者通知其他線程等待該對象（O）的監控器時，拋出該異常。

? ??java.lang.IllegalStateException：違法的狀態異常。當在Java環境和應用尚未處于某個方法的合法調用狀態，而調用了該方法時，拋出該異常。

? ??java.lang.IllegalThreadStateException：違法的線程狀態異常。當縣城尚未處于某個方法的合法調用狀態，而調用了該方法時，拋出異常。

? ??java.lang.IndexOutOfBoundsException：索引越界異常。當訪問某個序列的索引值小于0或大于等于序列大小時，拋出該異常。

? ??java.lang.InterruptedException：被中止異常。當某個線程處于長時間的等待、休眠或其他暫停狀態，而此時其他的線程通過Thread的interrupt方法終止該線程時拋出該異常。

? ??java.lang.TypeNotPresentException：類型不存在異常。當應用試圖以某個類型名稱的字符串表達方式訪問該類型，但是根據給定的名稱又找不到該類型是拋出該異常。該異常與ClassNotFoundException的區別在于該異常是unchecked（不被檢查）異常，而ClassNotFoundException是checked（被檢查）異常。

? ??java.lang.UnsupportedOperationException：不支持的方法異常。指明請求的方法不被支持情況的異常。

五、Java常見錯誤

? ? java.lang.AbstractMethodError：抽象方法錯誤。當應用試圖調用抽象方法時拋出。

? ? java.lang.AssertionError：斷言錯。用來指示一個斷言失敗的情況。

? ? java.lang.ClassCircularityError：類循環依賴錯誤。在初始化一個類時，若檢測到類之間循環依賴則拋出該異常。

? ? java.lang.ClassFormatError：類格式錯誤。當Java虛擬機試圖從一個文件中讀取Java類，而檢測到該文件的內容不符合類的有效格式時拋出。

? ? java.lang.Error：錯誤。是所有錯誤的基類，用于標識嚴重的程序運行問題。這些問題通常描述一些不應被應用程序捕獲的反常情況。

? ? java.lang.ExceptionInInitializerError：初始化程序錯誤。當執行一個類的靜態初始化程序的過程中，發生了異常時拋出。靜態初始化程序是指直接包含于類中的static語句段。

? ? java.lang.IllegalAccessError：違法訪問錯誤。當一個應用試圖訪問、修改某個類的域（Field）或者調用其方法，但是又違反域或方法的可見性聲明，則拋出該異常。

? ? java.lang.IncompatibleClassChangeError：不兼容的類變化錯誤。當正在執行的方法所依賴的類定義發生了不兼容的改變時，拋出該異常。一般在修改了應用中的某些類的聲明定義而沒有對整個應用重新編譯而直接運行的情況下，容易引發該錯誤。

? ? java.lang.InstantiationError：實例化錯誤。當一個應用試圖通過Java的new操作符構造一個抽象類或者接口時拋出該異常.

? ? java.lang.InternalError：內部錯誤。用于指示Java虛擬機發生了內部錯誤。

? ? java.lang.LinkageError：鏈接錯誤。該錯誤及其所有子類指示某個類依賴于另外一些類，在該類編譯之后，被依賴的類改變了其類定義而沒有重新編譯所有的類，進而引發錯誤的情況。

? ? java.lang.NoClassDefFoundError：未找到類定義錯誤。當Java虛擬機或者類裝載器試圖實例化某個類，而找不到該類的定義時拋出該錯誤。

? ? java.lang.NoSuchFieldError：域不存在錯誤。當應用試圖訪問或者修改某類的某個域，而該類的定義中沒有該域的定義時拋出該錯誤。

? ? java.lang.NoSuchMethodError：方法不存在錯誤。當應用試圖調用某類的某個方法，而該類的定義中沒有該方法的定義時拋出該錯誤。

? ? java.lang.OutOfMemoryError：內存不足錯誤。當可用內存不足以讓Java虛擬機分配給一個對象時拋出該錯誤。

? ? java.lang.StackOverflowError：堆棧溢出錯誤。當一個應用遞歸調用的層次太深而導致堆棧溢出時拋出該錯誤。

? ? java.lang.ThreadDeath：線程結束。當調用Thread類的stop方法時拋出該錯誤，用于指示線程結束。

? ? java.lang.UnknownError：未知錯誤。用于指示Java虛擬機發生了未知嚴重錯誤的情況。

? ? java.lang.UnsatisfiedLinkError：未滿足的鏈接錯誤。當Java虛擬機未找到某個類的聲明為native方法的本機語言定義時拋出。

? ? java.lang.UnsupportedClassVersionError：不支持的類版本錯誤。當Java虛擬機試圖從讀取某個類文件，但是發現該文件的主、次版本號不被當前Java虛擬機支持的時候，拋出該錯誤。

? ? java.lang.VerifyError：驗證錯誤。當驗證器檢測到某個類文件中存在內部不兼容或者安全問題時拋出該錯誤。

? ? java.lang.VirtualMachineError：虛擬機錯誤。用于指示虛擬機被破壞或者繼續執行操作所需的資源不足的情況。

六、自定義異常

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

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

? ? （1）創建自定義異常類。

? ? （2）在方法中通過throw關鍵字拋出異常對象。

? ? （3）如果在當前拋出異常的方法中處理異常，可以使用try-catch語句捕獲并處理；否則在方法的聲明處通過throws關鍵字指明要拋出給方法調用者的異常，繼續進行下一步操作。

? ? （4）在出現異常方法的調用者中捕獲并處理異常。

總結

以上是生活随笔為你收集整理的Java基础——Java异常处理机制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。