大家好，又見面了，我是你們的朋友全棧君。
一、 異常機制的概述
異常機制是指當程式出現錯誤後，程式如何處理。具體來說，異常機制提供了程式退出的安全通道。當出現錯誤後，程式執行的流程發生改變，程式的控制權轉移到異常處理器。
程式錯誤分為三種：1.編譯錯誤；2.運作時錯誤；3.邏輯錯誤。
（1）編譯錯誤是因為程式沒有遵循文法規則，編譯程式能夠自己發現并且提示我們錯誤的原因和位置，這個也是大家在剛接觸程式設計語言最常遇到的問題。
（2）運作時錯誤是因為程式在執行時，運作環境發現了不能執行的操作。
（3）邏輯錯誤是因為程式沒有按照預期的邏輯順序執行。異常也就是指程式運作時發生錯誤，而異常處理就是對這些錯誤進行處理和控制。
二、 異常的結構
在 Java 中，所有的異常都有一個共同的祖先 Throwable（可抛出）。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程式傳輸的任何問題的共性。
Throwable： 有兩個重要的子類：Exception（異常）和 Error（錯誤），二者都是 Java 異常處理的重要子類，各自都包含大量子類。異常和錯誤的差別是：異常能被程式本身可以處理，錯誤是無法處理。
Throwable類中常用方法如下：
1. 傳回異常發生時的詳細資訊
public string getMessage();
2. 傳回異常發生時的簡要描述
public string toString();
3. 傳回異常對象的本地化資訊。使用Throwable的子類覆寫這個方法，可以聲稱本地化資訊。如果子類沒有覆寫該方法，則該方法傳回的資訊與getMessage（）傳回的結果相同
public string getLocalizedMessage();
4. 在控制台上列印Throwable對象封裝的異常資訊
public void printStackTrace(); 複制
Error（錯誤）:是程式無法處理的錯誤，表示運作應用程式中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運作時 JVM（Java 虛拟機）出現的問題。例如，Java虛拟機運作錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的記憶體資源時，将出現 OutOfMemoryError。這些異常發生時，Java虛拟機（JVM）一般會選擇線程終止。這些錯誤表示故障發生于虛拟機自身、或者發生在虛拟機試圖執行應用時，如Java虛拟機運作錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應用程式的控制和處理能力之 外，而且絕大多數是程式運作時不允許出現的狀況。對于設計合理的應用程式來說，即使确實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。
Exception（異常）:是程式本身可以處理的異常。Exception 類有一個重要的子類RuntimeException。RuntimeException 類及其子類表示“JVM 常用操作”引發的錯誤。例如，若試圖使用空值對象引用、除數為零或數組越界，則分别引發運作時異常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
Exception（異常）分兩大類：運作時異常和非運作時異常(編譯異常)。程式中應當盡可能去處理這些異常。
1.運作時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下标越界異常)等，這些異常是不檢查異常，程式中可以選擇捕獲處理，也可以不處理。這些異常一般是由程式邏輯錯誤引起的，程式應該從邏輯角度盡可能避免這類異常的發生。運作時異常的特點是Java編譯器不會檢查它，也就是說，當程式中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明抛出它，也會編譯通過。
2.非運作時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬于Exception類及其子類。從程式文法角度講是必須進行處理的異常，如果不處理，程式就不能編譯通過。如IOException、SQLException等以及使用者自定義的Exception異常，一般情況下不自定義檢查異常。
通常，Java的異常（Throwable）分為可查的異常（checked exceptions）和不可查的異常（unchecked exceptions）。
1. 可查異常（編譯器要求必須處置的異常）：正确的程式在運作中，很容易出現的、情理可容的異常狀況。除了Exception中的RuntimeException及RuntimeException的子類以外，其他的Exception類及其子類(例如：IOException和ClassNotFoundException)都屬于可查異常。這種異常的特點是Java編譯器會檢查它，也就是說，當程式中可能出現這類異常，要麼用try-catch語句捕獲它，要麼用throws子句聲明抛出它，否則編譯不會通過。
2. 不可查異常(編譯器不要求強制處置的異常)：包括運作時異常（RuntimeException與其子類）和錯誤（Error）。RuntimeException表示編譯器不會檢查程式是否對RuntimeException作了處理，在程式中不必捕獲RuntimException類型的異常，也不必在方法體聲明抛出RuntimeException類。RuntimeException發生的時候，表示程式中出現了程式設計錯誤，是以應該找出錯誤修改程式，而不是去捕獲RuntimeException。
三、 異常處理的機制
在 Java 應用程式中，異常處理機制為：抛出異常，捕捉異常。
1. 抛出異常：當一個方法出現錯誤引發異常時，方法建立異常對象并傳遞運作時系統，異常對象中包含了異常類型和異常出現時的程式狀态等異常資訊。運作時系統負責尋找處置異常的代碼并執行。。
任何Java代碼都可以抛出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運作時系統。無論是誰，都可以通過Java的throw語句抛出異常。從方法中抛出的任何異常都必須使用throws子句。
一、throws抛出異常
如果一個方法可能會出現異常，但沒有能力處理這種異常，可以在方法聲明處用throws子句來聲明抛出異常。例如汽車在運作時可能會出現故障，汽車本身沒辦法處理這個故障，那就讓開車的人來處理。
throws語句用在方法定義時聲明該方法要抛出的異常類型，如果抛出的是Exception異常類型，則該方法被聲明為抛出所有的異常。多個異常可使用逗号分割。throws語句的文法格式為：
methodname throws Exception1,Exception2,..,ExceptionN { } 複制
方法名後的throws Exception1,Exception2,…,ExceptionN 為聲明要抛出的異常清單。當方法抛出異常清單的異常時，方法将不對這些類型及其子類類型的異常作處理，而抛向調用該方法的方法，由他去處理。
使用throws關鍵字将異常抛給調用者後，如果調用者不想處理該異常，可以繼續向上抛出，但最終要有能夠處理該異常的調用者。
Throws抛出異常的規則：
1: 如果是不可查異常（unchecked exception），即Error、RuntimeException或它們的子類，那麼可以不使用throws關鍵字來聲明要抛出的異常，編譯仍能順利通過，但在運作時會被系統抛出。
2: 如果一個方法可能出現可查異常（checked exception），要麼用try-catch語句捕獲，要麼用throws子句聲明将它抛出，否則會導緻編譯錯誤。
3: 隻有當抛出了異常時，該方法的調用者才必須處理或者重新抛出該異常。當方法的調用者無力處理該異常的時候，應該繼續抛出。
4: 調用方法必須遵循任何可查異常的處理和聲明規則。若覆寫一個方法，則不能聲明與覆寫方法不同的異常。聲明的任何異常必須是被覆寫方法所聲明異常的同類或子類。
例子1
package com.softeem.wolf.exception;
/**
* Created by 蒼狼
* Time on 2021-10-28
*/
public class ExceptionTest02 {
public static void main(String[] args) {
System.out.println("程式執行開始的地方...");
try{
method1();
} catch (ArithmeticException e){
System.out.println("我來解決這個問題了...");
} finally {
System.out.println("我是main中finally執行的代碼.....");
}
System.out.println("main方法執行的最後一個方法....");
}
public static void method1() throws ArithmeticException{
int a = 10;
int b = 0;
System.out.println("進入異常的開頭....");
System.out.println(a/b);
System.out.println("try結束所執行的.....");
System.out.println("正常執行");
System.out.println("我是method1()最後執行的代碼....");
}
} 複制
執行結果
程式執行開始的地方…
進入異常的開頭….
我來解決這個問題了…
我是main中finally執行的代碼…..
main方法執行的最後一個方法….
代碼分析: 首先main方法開始執行, 執行第一個語句, 然後調用method1()方法, 但執行到System.out.println(a/b)時報錯, 但是method1()方法并沒有解決這個異常, 是以method1()後面的代碼終止執行, 回到main方法中, main方法将其解決了, 執行了catch{}裡面語句, 最後finally{}語句, 最後執行main方法最後的語句.
例子2
package com.softeem.wolf.exception;
/**
* Created by 蒼狼
* Time on 2021-10-28
*/
public class ExceptionTest02 {
public static void main(String[] args) throws ArithmeticException{
System.out.println("程式執行開始的地方...");
try{
method1();
} finally {
System.out.println("我是main中finally執行的代碼.....");
}
System.out.println("main方法執行的最後一個方法....");
}
public static void method1() throws ArithmeticException{
int a = 10;
int b = 0;
System.out.println("進入異常的開頭....");
System.out.println(a/b);
System.out.println("try結束所執行的.....");
System.out.println("正常執行");
System.out.println("我是method1()最後執行的代碼....");
}
} 複制
運作結果
Exception in thread “main” java.lang.ArithmeticException: / by zero
at com.softeem.wolf.exception.ExceptionTest02.method1(ExceptionTest02.java:23)
at com.softeem.wolf.exception.ExceptionTest02.main(ExceptionTest02.java:11)
程式執行開始的地方…
進入異常的開頭….
我是main中finally執行的代碼…..
代碼分析: 首先也是執行main方法的開始語句, 後面跳到method1()中, 執行到了System.out.println(a/b)語句時, 發現異常, 但是method1()并沒有将他解決, 是以method1()方法終止執行, 回跳到main方法中, 但是main()方法也沒有對他進行解決, 是以main方法也結束了, 不繼續執行了. 但是由于finally的存在, 是以它得執行完finally{}語句之後在結束.
二、使用throw抛出異常
throw總是出現在方法體中，用來抛出一個Throwable類型的異常。程式會在throw語句後立即終止，它後面的語句執行不到，然後在包含它的所有try塊中（可能在上層調用函數中）從裡向外尋找含有與其比對的catch子句的try塊。
我們知道，異常是異常類的執行個體對象，我們可以建立異常類的執行個體對象通過throw語句抛出。該語句的文法格式為：
throw new exceptionname; 複制
例如抛出一個IOException類的異常對象：
throw new IOException; 複制
要注意的是，throw 抛出的隻能夠是可抛出類Throwable 或者其子類的執行個體對象。下面的操作是錯誤的，因為String 不是Throwable 類的子類。
throw new String("exception"); 複制
如果抛出了可查異常，則還應該在方法頭部聲明方法可能抛出的異常類型。該方法的調用者也必須檢查處理抛出的異常。
如果所有方法都層層上抛擷取的異常，最終JVM會進行處理，處理也很簡單，就是列印異常消息和堆棧資訊。如果抛出的是Error或RuntimeException，則該方法的調用者可選擇處理該異常。
throw的示例
package com.softeem.wolf.exception;
/**
* Created by 蒼狼
* Time on 2021-10-28
*/
public class ExceptionTest02 {
public static void main(String[] args) throws ArithmeticException{
System.out.println("程式執行開始的地方...");
try{
method1();
//當這裡有異常發生時, 後面的代碼也都不會執行, 這裡指的就是method1()方法有異常
//System.out.println("這裡的代碼不會在執行了...");
} catch (ArithmeticException e){
System.out.println("解決異常");
} finally{
System.out.println("我是main中finally執行的代碼.....");
}
System.out.println("main方法執行的最後一個方法....");
}
public static void method1(){
int a = 10;
int b = 0;
System.out.println("進入異常的開頭....");
throw new ArithmeticException();
//System.out.println("這裡不能再寫程式了....");
}
} 複制
運作結果:
程式執行開始的地方…
進入異常的開頭….
解決異常
我是main中finally執行的代碼…..
main方法執行的最後一個方法….
代碼分析: main方法開始執行, 執行開頭語句, 然後調用method1()方法, 進入method1()方法, 但執行到throw new ArithmeticException(); 退出執行, 這裡注意(throw new ArithmeticException(); 後面不能再繼續寫程式了, 會報錯), 然後跳到main方法, main方法對它進行了解決, main方法的程式正常執行.
三、比較
3.1 在聲明方法時候抛出異常
文法：throws（略） 複制
問1: 為什麼要在聲明方法抛出異常？
答：方法是否抛出異常與方法傳回值的類型一樣重要。假設方法抛出異常卻沒有聲明該方法将抛出異常，那麼客戶程式員可以調用這個方法而且不用編寫處理異常的代碼。那麼，一旦出現異常，那麼這個異常就沒有合适的異常控制器來解決。
問2: 為什麼抛出的異常一定是可檢查異常(除了Exception中的RuntimeException及其子類以外，其他的Exception類及其子類)？
答：RuntimeException與Error可以在任何代碼中産生，它們不需要由程式員顯示的抛出，一旦出現錯誤，那麼相應的異常會被自動抛出。遇到Error，程式員一般是無能為力的；遇到RuntimeException，那麼一定是程式存在邏輯錯誤，要對程式進行修改；隻有可檢查異常才是程式員所關心的，程式應該且僅應該抛出或處理可檢查異常。而可檢查異常是由程式員抛出的，這分為兩種情況：客戶程式員調用會抛出異常的庫函數；客戶程式員自己使用throw語句抛出異常。
注意： 覆寫父類某方法的子類方法不能抛出比父類方法更多的異常，是以，有時設計父類的方法時會聲明抛出異常，但實際的實作方法的代碼卻并不抛出異常，這樣做的目的就是為了友善子類方法覆寫父類方法時可以抛出異常。(重寫方法抛出的異常一定要比父類方法更加精确, 也就是範圍更小, 同樣也不能抛出父類沒有的異常).
3.2 在方法中抛出異常
文法：throw（略） 複制
問1: 抛出什麼異常？
答：對于一個異常對象，真正有用的資訊是異常的對象類型，而異常對象本身毫無意義。比如一個異常對象的類型是ClassCastException，那麼這個類名就是唯一有用的資訊。是以，在選擇抛出什麼異常時，最關鍵的就是選擇異常的類名能夠明确說明異常情況的類。
異常對象通常有兩種構造函數：一種是無參數的構造函數；另一種是帶一個字元串的構造函數，這個字元串将作為這個異常對象除了類型名以外的額外說明。
問2: 為什麼要使用finally塊釋放資源?
答: finally關鍵字保證無論程式使用任何方式離開try塊，finally中的語句都會被執行。是以，當你需要一個地方來執行在任何情況下都必須執行的代碼時，就可以将這些代碼放入finally塊中。當你的程式中使用了外界資源，如資料庫連接配接，檔案等，必須将釋放這些資源的代碼寫入finally塊中。
注意： 在finally塊中不能抛出異常。JAVA異常處理機制保證無論在任何情況下必須先執行finally塊然後再離開try塊，是以在try塊中發生異常的時候，JAVA虛拟機先轉到finally塊執行finally塊中的代碼，finally塊執行完畢後，再向外抛出異常。如果在finally塊中抛出異常，try塊捕捉的異常就不能抛出，外部捕捉到的異常就是finally塊中的異常資訊，而try塊中發生的真正的異常堆棧資訊則丢失了。
2. 捕獲異常：在方法抛出異常之後，運作時系統将轉為尋找合适的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法抛出的異常類型相符時，即為合适 的異常處理器。運作時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合适異常處理器的方法并執行。當運作時系統周遊調用棧而未找到合适 的異常處理器，則運作時系統終止。同時，意味着Java程式的終止。
一、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塊捕獲的異常類型相比對。
注意：一旦某個catch捕獲到比對的異常類型，将進入異常處理代碼。一經處理結束，就意味着整個try-catch語句結束。其他的catch子句不再有比對和捕獲異常類型的機會。
注意: Java通過異常類描述異常類型，對于有多個catch子句的異常程式而言，應該盡量将捕獲底層異常類的catch子句放在前面，同時盡量将捕獲相對高層的異常類的catch子句放在後面。否則，捕獲底層異常類的catch子句将可能會被屏蔽。
例如：RuntimeException異常類包括運作時各種常見的異常，ArithmeticException類和ArrayIndexOutOfBoundsException類都是它的子類。是以，RuntimeException異常類的catch子句應該放在 最後面，否則可能會屏蔽其後的特定異常處理或引起編譯錯誤
二、try-catch-finally語句
try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現異常，都應當執行的内容。try-catch-finally語句的一般文法形式為：
try {
// 可能會發生異常的程式代碼
} catch (Type1 id1){
// 捕獲并處置try抛出的異常類型Type1
} catch (Type2 id2){
//捕獲并處置try抛出的異常類型Type2
}finally {
// 無論是否發生異常，都将執行的語句塊
} 複制
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語句塊後的語句。
三、小結
1: try 塊：用于捕獲異常。其後可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。
2: catch 塊：用于處理try捕獲到的異常。
3: finally 塊：無論是否捕獲或處理異常，finally塊裡的語句都會被執行。當在try塊或catch塊中遇 到return語句時，finally語句塊将在方法傳回之前被執行。在以下4種特殊情況下，finally塊不會被執行：
1）在finally語句塊中發生了異常。
2）在前面的代碼中用了System.exit()退出程式。
3）程式所在的線程死亡。
4）關閉CPU。
詳細了解try-catch-finallyz中return傳回情況，可檢視文章《Java：簡述try-catch-finally中return傳回》。
注意:
對于錯誤、運作時異常、可查異常，Java技術所要求的異常處理方式有所不同。
1. 錯誤：對于方法運作中可能出現的Error，當運作方法不欲捕捉時，Java允許該方法不做任何抛出聲明。因為，大多數Error異常屬于永遠不能被允許發生的狀況，也屬于合理的應用程式不該捕捉的異常。
2. 運作時異常：由于運作時異常的不可查性，為了更合理、更容易地實作應用程式，Java規定，運作時異常将由Java運作時系統自動抛出，允許應用程式忽略運作時異常。
3. 可查異常：對于所有的可查異常，Java規定：一個方法必須捕捉，或者聲明抛出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明将抛出異常。
能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由于自身語句所引發并抛出的異常，也可能是由某個調用的方法或者Java運作時 系統等抛出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所抛出的異常。簡單地說，異常總是先被抛出，後被捕捉的。
異常抛出：任何Java代碼都可以抛出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運作時系統。無論是誰，都可以通過Java的throw語句抛出異常。從方法中抛出的任何異常都必須使用throws子句。
異常捕獲：捕捉異常通過try-catch語句或者try-catch-finally語句實作。
總體來說，Java規定：對于可查異常必須捕捉、或者聲明抛出。允許忽略不可查的RuntimeException和Error。
四、Java常見異常
1. RuntimeException子類:
2.IOException
3. 其他
五、相關的問題
1. 為什麼要建立自己的異常？
答：當Java内置的異常都不能明确的說明異常情況的時候，需要建立自己的異常。
2. 應該在聲明方法抛出異常還是在方法中捕獲異常？
答：捕捉并處理知道如何處理的異常，而抛出不知道如何處理的異常。
文章參考與: Java：詳解Java中的異常(Error與Exception)_王小二(海闊天空)-CSDN部落格
釋出者：全棧程式員棧長，轉載請注明出處：https://javaforall.cn/156435.html原文連結：https://javaforall.cn