1:try…catch…finally恐怕是大家再熟悉不過的語句了

2:異常指不期而至的各種狀況，如：檔案找不到、網路連線失敗、非法引數等。異常是一個事件，它發生在程式執行期間，干擾了正常的指令流程。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。

捕獲異常：try、catch 和 finally

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

1. try {

2. // 可能會發生異常的程式程式碼

3. } catch (Type1 id1){

4. // 捕獲並處置try丟擲的異常型別Type1

5. }

6. catch (Type2 id2){

7. //捕獲並處置try丟擲的異常型別Type2

8. }

關鍵詞try後的一對大括號將一塊可能發生異常的程式碼包起來，稱為監控區域。Java方法在執行過程中出現異常，則建立異常物件。將異常丟擲監控區域之 外，由Java執行時系統試圖尋找匹配的catch子句以捕獲異常。若有匹配的catch子句，則執行其異常處理程式碼，try-catch語句結束。匹配的原則是：如果丟擲的異常物件屬於catch子句的異常類，或者屬於該異常類的子類，則認為生成的異常物件與catch塊捕獲的異常型別相匹配。

try－catch-finally語句

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

1. try {

2. // 可能會發生異常的程式程式碼

3. } catch (Type1 id1) {

4. // 捕獲並處理try丟擲的異常型別Type1

5. } catch (Type2 id2) {

6. // 捕獲並處理try丟擲的異常型別Type2

7. } finally {

8. // 無論是否發生異常，都將執行的語句塊

9. }

總結:try 塊：用於捕獲異常。其後可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。catch 塊：用於處理try捕獲到的異常。finally 塊：無論是否捕獲或處理異常，finally塊裡的語句都會被執行。當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執行。在以下4種特殊情況下，finally塊不會被執行：1）在finally語句塊中發生了異常。2）在前面的程式碼中用了System.exit()退出程式。3）程式所在的執行緒死亡。4）關閉CPU。

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語句塊時，此異常將會拋給JVM處理，finally語句塊裡的語句還是會被執行，但finally語句塊後的語句不會被執行；

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

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

丟擲異常

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

throws丟擲異常

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

throws語句用在方法定義時宣告該方法要丟擲的異常型別，如果丟擲的是Exception異常型別，則該方法被宣告為丟擲所有的異常。多個異常可使用逗號分割。throws語句的語法格式為：

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

方法名後的throws Exception1,Exception2,...,ExceptionN 為宣告要丟擲的異常列表。當方法丟擲異常列表的異常時，方法將不對這些型別及其子類型別的異常作處理，而拋向呼叫該方法的方法，由他去處理

Throws丟擲異常的規則：

1) 如果是不可查異常（unchecked exception），即Error、RuntimeException或它們的子類，那麼可以不使用throws關鍵字來宣告要丟擲的異常，編譯仍能順利透過，但在執行時會被系統丟擲。2）必須宣告方法可丟擲的任何可查異常（checked exception）。即如果一個方法可能出現受可查異常，要麼用try-catch語句捕獲，要麼用throws子句宣告將它丟擲，否則會導致編譯錯誤

3)僅當丟擲了異常，該方法的呼叫者才必須處理或者重新丟擲該異常。當方法的呼叫者無力處理該異常的時候，應該繼續丟擲，而不是囫圇吞棗。

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

判斷一個方法可能會出現異常的依據如下：

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; }

異常鏈

1) 如果呼叫quotient(3,-1)，將發生MyException異常，程式調轉到catch (MyException e)程式碼塊中執行；

2) 如果呼叫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.4 Throwable類中的常用方法

注意：catch關鍵字後面括號中的Exception型別的引數e。Exception就是try程式碼塊傳遞給catch程式碼塊的變數型別，e就是變數名。catch程式碼塊中語句"e.getMessage();"用於輸出錯誤性質。通常異常處理常用3個函式來獲取異常的有關資訊:

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

getMeage()：返回異常的訊息資訊。

printStackTrace()：物件的堆疊跟蹤輸出至錯誤輸出流，作為欄位 System.err 的值。

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

5.Java常見異常

在Java中提供了一些異常用來描述經常發生的錯誤，對於這些異常，有的需要程式設計師進行捕獲處理或宣告丟擲，有的是由Java虛擬機器自動進行捕獲處理。Java中常見的異常類:

1. runtimeException子類:

1、 java.lang.ArrayIndexOutOfBoundsException陣列索引越界異常。當對陣列的索引值為負數或大於等於陣列大小時丟擲。2、java.lang.ArithmeticException算術條件異常。譬如：整數除零等。3、java.lang.NullPointerException空指標異常。當應用試圖在要求使用物件的地方使用了null時，丟擲該異常。譬如：呼叫null物件的例項方法、訪問null物件的屬性、計算null物件的長度、使用throw語句丟擲null等等4、java.lang.ClassNotFoundException找不到類異常。當應用試圖根據字串形式的類名構造類，而在遍歷CLASSPAH之後找不到對應名稱的class檔案時，丟擲該異常。

5、java.lang.NegativeArraySizeException 陣列長度為負異常

6、java.lang.ArrayStoreException 陣列中包含不相容的值丟擲的異常

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

8、java.lang.IllegalArgumentException 非法引數異常

2.IOException

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

EOFException 檔案已結束異常

FileNotFoundException 檔案未找到異常

3. 其他

ClassCastException 型別轉換異常類

ArrayStoreException 陣列中包含不相容的值丟擲的異常

SQLException 操作資料庫異常類

NoSuchFieldException 欄位未找到異常

NoSuchMethodException 方法未找到丟擲的異常

NumberFormatException 字串轉換為數字丟擲的異常

StringIndexOutOfBoundsException 字串索引超出範圍丟擲的異常

IllegalAccessException 不允許訪問某類異常

InstantiationException 當應用程式試圖使用Class類中的newInstance()方法建立一個類的例項，而指定的類物件無法被例項化時，丟擲該異常

6.自定義異常

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

在程式中使用自定義異常類，大體可分為以下幾個步驟。（1）建立自定義異常類。（2）在方法中透過throw關鍵字丟擲異常物件。（3）如果在當前丟擲異常的方法中處理異常，可以使用try-catch語句捕獲並處理；否則在方法的宣告處透過throws關鍵字指明要丟擲給方法呼叫者的異常，繼續進行下一步操作。（4）在出現異常方法的呼叫者中捕獲並處理異常。