Java&&深入理解異常處理
簡介
異常處理是java語言的重要特性之一，《Three Rules for effective Exception Handling》一文中是這麼解釋的：它主要幫助我們在debug的過程中解決下面的三個問題。
- 什麼出錯了
- 哪裡出錯了
- 為什麼出錯
java語言可以說是提供了完善的異常處理機制。java中的異常機制包括Error和Exception兩個部分。他們都繼承自一個共同的基類Throwable。
Error：屬於JVM執行中發生的一些錯誤，雖然並不屬於開發人員的範疇，而是程式碼執行時JVM出現的問題，但是有些Error還是由程式碼引起的。比如StackOverflowError經常由遞迴操作引起，這種錯誤就是告訴開發者，你一般無法挽救，只能靠JVM，例如，
Exception：是程式本身可以處理的異常。(注意：異常和錯誤的區別：異常能被程式本身可以處理，錯誤是無法處理)假設程式設計師會去處理這些異常，比如資料庫連接出了異常，那麼我們可以處理這個異常，並且重新連線等。Exception分為兩種，檢查型別（checked）和未檢查型別（unchecked）。檢查型別的異常就是說要程式設計師明確的去宣告(throws)或者用try..catch語句來處理的異常，否則編譯不會通過。 除了RuntimeException及其子類以外，其他的Exception類及其子類都屬於可查異常。而非檢查型別的異常則沒有這些限制，比如我們常見的 NullPointerException 就是非檢查型別的，他繼承自RuntimeException。java是目前主流程式語言中唯一一個推崇使用檢查型別異常的，至少sun是這樣的。關於使用checked還是unchecked異常的論戰一直很激烈。
綜上：
Exception 這種異常分兩大類執行時異常和非執行時異常(編譯異常)。程式中應當儘可能去處理這些異常。
執行時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指標異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不檢查異常，程式中可以選擇捕獲處理，也可以不處理。這些異常一般是由程式邏輯錯誤引起的，程式應該從邏輯角度儘可能避免這類異常的發生。
執行時異常的特點是Java編譯器不會檢查它，也就是說，當程式中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句宣告丟擲它，也會編譯通過。
非執行時異常 （編譯異常）：是RuntimeException以外的異常，型別上都屬於Exception類及其子類。從程式語法角度講是必須進行處理的異常，如果不處理，程式就不能編譯通過。如IOException、SQLException等以及使用者自定義的Exception異常，一般情況下不自定義檢查異常。
下面是一張java語言中異常的類關係圖。
處理機制
在 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.try-catch語句
我們在使用java的一些檔案或者資料庫操作的時候已經接觸過一些異常了，比如IOException、SQLException等，這些方法被宣告可能會丟擲某種異常，因此我們需要對其進行捕獲處理。這就需要基本的try..catch語句了。下圖就是我們經常寫的一個基本結構。try語句塊中寫可能會丟擲異常的程式碼，之後在catch語句塊中進行捕獲。我們看到catch的引數寫的是一個Exception物件，這就意味著這個語句塊可以捕獲所有的檢查型別的異常（雖然這並不是一種好的寫法，稍後討論），finally總是會保證在最後執行，一般我們在裡面處理一些清理的工作，比如關閉檔案流或者資料庫、網路等操作。
當然上面的語句塊結構是靈活的，但是try是必須有的，catch和finally兩者至少有一個，當然catch的數量可以有多個。有時候try語句塊中可能丟擲多種型別的異常，這個時候，我們可以寫多個catch語句來捕獲不同型別的異常，一個比較好的寫法如下：
try{
// ..invoke some methods that may throw exceptions
}catch(ExceptionType1 e){
//...handle exception
}catch(ExceptionType2 e){
//...handle exception
}catch(Exception e){
//...handle exception
}finally{
//..do some cleaning :close the file db etc.
}初次學習try..catch總會被其吸引，所以大量的使用這種結果，以達到某種“魯棒性”。（這語句也是程式設計師表白的最愛）。但try語句實際上執行的時候會導致棧操作。即要儲存整個方法的呼叫路徑，這勢必會使得程式變慢。fillInStackTrace()是Throwable的一個方法，用來執行棧的操作，他是執行緒同步的，本身也很耗時。這裡問題在StackOverFlow上曾經有過一段非常經典的討論，原文。 的確當我們在try中什麼都不做，或者只執行一個類似加法的簡單呼叫，那麼其執行效率和goto這樣的控制語句是幾乎一樣的。但是誰會寫這樣的程式碼呢？
總之不要總是試圖通過try catch來控制程式的結構，無論從效率還是程式碼的可讀性上都不好。
try catch好的一面
try catch雖然不推薦用於程式結構的控制，但是也具有重要的意義，其設計的一個好處就是，開發人員可以把一件事情當做事務來處理，事務也是資料庫中重要的概念，舉個例子，比如完成訂單的這個事務，其中包括了一個動作序列，包括使用者提交訂單，商品出庫，關聯等。當這個序列中某一個動作執行失敗的時候，資料統一恢復到一個正常的點，這樣就不會出現，你付完了帳，商品卻沒有給你的情況。我們在try語句塊中就像執行一個事務一樣，當出現了異常，就會在catch中得到統一的處理，保證資料的完整無損。其實很多不好的程式碼也是因為沒有好好利用catch語句的語言，導致很多異常就被淹沒了，這個後面介紹。
舉例
例1 捕捉throw語句丟擲的“除數為0”異常。
<span style="font-size:12px;">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("程式正常結束。");
}
} </span>執行結果：程式出現異常，變數b不能為0。
程式正常結束。
例1 在try監控區域通過if語句進行判斷，當“除數為0”的錯誤條件成立時引發ArithmeticException異常，建立 ArithmeticException異常物件，並由throw語句將異常拋給Java執行時系統，由系統尋找匹配的異常處理器catch並執行相應異 常處理程式碼，列印輸出“程式出現異常，變數b不能為0。”try-catch語句結束，繼續程式流程。
事實上，“除數為0”等ArithmeticException，是RuntimException的子類。而執行時異常將由執行時系統自動丟擲，不需要使用throw語句。
例2 捕捉執行時系統自動丟擲“除數為0”引發的ArithmeticException異常。
<span style="font-size:12px;">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("程式正常結束。");
}
} </span>執行結果：程式出現異常，變數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子句的異常處理程式。
- publicclass TestException {
- publicstaticvoid 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 塊中丟擲一個未處理的異常；計算機斷電、失火、或遭遇病毒攻擊。
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語句塊後的語句。
如下圖所示：
圖2 圖示try、catch、finally語句塊的執行
丟擲異常
任何Java程式碼都可以丟擲異常，如：自己編寫的程式碼、來自Java開發環境包中程式碼，或者Java執行時系統。無論是誰，都可以通過Java的throw語句丟擲異常。從方法中丟擲的任何異常都必須使用throws子句。
1. throws丟擲異常
如果一個方法可能會出現異常，但沒有能力處理這種異常，可以在方法宣告處用throws子句來宣告丟擲異常。例如汽車在執行時可能會出現故障，汽車本身沒辦法處理這個故障，那就讓開車的人來處理。
使用throws關鍵字將異常拋給呼叫者後，如果呼叫者不想處理該異常，可以繼續向上丟擲，但最終要有能夠處理該異常的呼叫者。
pop方法沒有處理異常NegativeArraySizeException，而是由main函式來處理。
throws語句用在方法定義時宣告該方法要丟擲的異常型別，如果丟擲的是Exception異常型別，則該方法被宣告為丟擲所有的異常。多個異常可使用逗號分割。throws語句的語法格式為：
-
方法名後的throws Exception1,Exception2,...,ExceptionN 為宣告要丟擲的異常列表。當方法丟擲異常列表的異常時，方法將不對這些型別及其子類型別的異常作處理，而拋向呼叫該方法的方法，由他去處理。例如：methodname throws Exception1,Exception2,..,ExceptionN{} -
import java.lang.Exception; 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，則該方法的呼叫者可選擇處理該異常。
<span style="font-size:12px;">package Test;
import java.lang.Exception;
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;
}
} </span>異常鏈
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語句的順序不可掉換。
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中常見的異常類: