Java基礎 -- 深刻理解Java異常機制

時間 2020-05-06

標籤 java 基礎深刻理解異常機制欄目 Java 简体版

原文原文鏈接

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

一異常分類

Java異常類層次結構圖：程序員

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

一、Throwable：有兩個重要的子類：Exception和 Error兩者都是 Java 異常處理的重要子類，各自都包含大量子類。編程

Error：是程序沒法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操做無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 再也不有繼續執行操做所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）通常會選擇線程終止。
Exception：是程序自己能夠處理的異常。Exception 類有一個重要的子類 RuntimeException。RuntimeException 類及其子類表示「JVM 經常使用操做」引起的錯誤。例如，若試圖使用空值對象引用、除數爲零或數組越界，則分別引起運行時異常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。

注意：異常和錯誤的區別：異常能被程序自己能夠處理，錯誤是沒法處理。數組

二、一般，Java的異常分爲可查的異常（checked exceptions）和不可查的異常（unchecked exceptions）。安全

可查異常（編譯器要求必須處置的異常）：除了RuntimeException及其子類之外，其餘的Exception類及其子類都屬於可查異常。Java編譯器要求對檢查異常必須捕獲或拋出，代碼邏輯沒有錯誤，但程序運行時會由於IO等錯誤致使異常，你在編寫程序階段是預料不到的。若是不處理這些異常，程序未來可能會出錯。因此編譯器會提示你要去捕獲並處理這種可能發生的異常，不處理就不能經過編譯。

不可查異常(編譯器不要求強制處置的異常)：包括運行時異常（RuntimeException與其子類）和錯誤（Error）。Java編譯器不要求對不可查異常必定捕獲或拋出，能夠不作處理，此類異常一般是在邏輯上有錯誤，能夠經過修改代碼避免。

三、Exception 又可分兩大類：運行時異常和非運行時異常(編譯異常)，程序中應當儘量去處理這些異常。網絡

運行時異常（比不可查異常少了Error）：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不可查異常，程序中能夠選擇捕獲處理，也能夠不處理。這些異常通常是由程序邏輯錯誤引發的，程序應該從邏輯角度儘量避免這類異常的發生。

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

非運行時異常（編譯器要求必須處置的異常，也就是可查類型）：是RuntimeException之外的異常，類型上都屬於Exception類及其子類。從程序語法角度講是必須進行處理的異常，若是不處理，程序就不能編譯經過。如IOException、SQLException等以及用戶自定義的Exception異常，通常狀況下不自定義檢查異常。

二異常處理機制

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

拋出異常：當一個方法出現錯誤引起異常時，方法建立異常對象並交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼並執行。
捕獲異常：在方法拋出異常以後，運行時系統將轉爲尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即爲合適的異常處理器。運行時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合適異常處理器的方法並執行。當運行時系統遍歷調用棧而未找到合適的異常處理器，則運行時系統終止。同時，意味着Java程序的終止。

對於不可查異常(RuntimeException、Error)或可查異常(除了RuntimeException及其子類之外，其餘的Exception類及其子類)，Java技術所要求的異常處理方式有所不一樣。編碼

RuntimeException異常：因爲RuntimeException異常的不可查性，爲了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，容許應用程序忽略運行時異常。
Error：對於方法運行中可能出現的Error，當運行方法不欲捕捉時，Java容許該方法不作任何拋出聲明。由於，大多數Error異常屬於永遠不能被容許發生的情況，也屬於合理的應用程序不應捕捉的異常。
除了RuntimeException及其子類之外，其餘的Exception類及其子類：對於全部的可查異常，Java規定：一個方法必須捕捉，或者聲明拋出方法（也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常）。

可以捕捉異常的方法，須要提供相符類型的異常處理器。所捕捉的異常，多是因爲自身語句所引起並拋出的異常，也多是由某個調用的方法或者Java運行時系統等拋出的異常。也就是說，一個方法所能捕捉的異常，必定是Java代碼在某處所拋出的異常。簡單地說，異常老是先被拋出，後被捕捉的。
任何Java代碼均可以拋出異常，如：本身編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。不管是誰，均可以經過Java的throw語句拋出異常。
從方法中拋出的任何異常都必須使用throws子句。
捕捉異常經過try-catch語句或者try-catch-finally語句實現。
整體來講，Java規定：對於可查異常必須捕捉、或者聲明拋出。容許忽略不可查的RuntimeException和Error。

三 try-catch語句

在Java中，異常經過try-catch語句捕獲，其通常語法形式爲：

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

關鍵字try後的一對大括號將一塊可能發生異常的代碼包起來，稱爲監控區域(guarded region)。Java方法在運行過程當中出現異常，則建立異常對象。將異常拋出監控區域之外，Java異常處理機制將負責搜尋參數與異常類型相匹配的第一個處理程序。如有匹配的catch子句，則運行其異常處理代碼，try-catch語句結束。

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

一、捕捉throw語句拋出的「除數爲0」異常

public class TestException1 { 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。 程序正常結束。

上例中在try監控區域經過if語句進行判斷，當「除數爲0」的錯誤條件成立時引起ArithmeticException異常，建立 ArithmeticException異常對象，並由throw語句將異常拋給Java運行時系統，由系統尋找匹配的異常處理器catch並運行相應異常處理代碼。
事實上，「除數爲0」等ArithmeticException異常，是RuntimException的子類。而運行時異常將由運行時系統自動拋出，不須要使用throw語句。

二、捕捉運行時系統自動拋出「除數爲0」引起的ArithmeticException異常

public class TestException1 { public static void main(String[] args) { int a = 6; int b = 0; try { // try監控區域 System.out.println("a/b的值是：" + a / b); } catch (ArithmeticException e) { // catch捕捉異常 System.out.println("程序出現異常，變量b不能爲0。"); } System.out.println("程序正常結束。"); } }

輸出結果：

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

上例中System.out.println("a/b的值是：" + a/b)語句，在運行中出現「除數爲0」錯誤，引起ArithmeticException異常。運行時系統建立異常對象並拋出監控區域，轉而匹配合適的異常處理器catch，並執行相應的異常處理代碼。
因爲檢查運行時異常的代價遠大於捕捉異常所帶來的益處，運行時異常不可查。Java編譯器容許忽略運行時異常，一個方法能夠既不捕捉，也不聲明拋出運行時異常。

三、不捕捉、也不聲明拋出運行時異常

 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)

四、程序可能存在除數爲0異常和數組下標越界異常

public class TestException2 { 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 = -1 intArray[2] = 2 除數爲0異常。 程序正常結束

程序可能會出現除數爲0異常，還可能會出現數組下標越界異常。程序運行過程當中ArithmeticException異常類型是先行匹配的，所以執行相匹配的catch語句：

catch(ArrayIndexOutOfBoundsException e) { System.out.println("intArray數組下表越界異常。"); }

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

四 try－catch-finally語句

try-catch語句還能夠包括第三部分，就是finally子句。它表示不管是否出現異常，都應當執行的內容。try-catch-finally語句的通常語法形式爲：

 try { // 可能會發生異常的程序代碼 } catch (Type1 id1) { // 捕獲並處理try拋出的異常類型Type1 } catch (Type2 id2) { // 捕獲並處理try拋出的異常類型Type2 } finally { // 不管是否發生異常，都將執行的語句塊 }

一、帶finally子句的異常處理程序

public class TestException3 { 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 !!! -------------------------- 數組下標越界異常 --------------------------

小結：

一、try 塊：用於捕獲異常。其後可接零個或多個catch塊，若是沒有catch塊，則必須跟一個finally塊；

二、catch 塊：用於處理try捕獲到的異常；

三、finally 塊：不管是否捕獲或處理異常，finally塊裏的語句都會被執行。當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回以前被執行。在如下4種特殊狀況下，finally塊不會被執行：

在finally語句塊中發生了異常；
在前面的代碼中用了System.exit()退出程序；
程序所在的線程死亡；
關閉CPU；

五 try-catch-finally 規則(異常處理語句的語法規則）

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

六 try、catch、finally語句塊的執行順序

當try沒有捕獲到異常時：try語句塊中的語句逐一被執行，程序將跳過catch語句塊，執行finally語句塊和其後的語句；
當try捕獲到異常，catch語句塊裏沒有處理此異常的狀況：當try語句塊裏的某條語句出現異常時，而沒有處理此異常的catch語句塊時，此異常將會拋給JVM處理，finally語句塊裏的語句仍是會被執行，但finally語句塊後的語句不會被執行；
當try捕獲到異常，catch語句塊裏有處理此異常的狀況：在try語句塊中是按照順序來執行的，當執行到某一條語句出現異常時，程序將跳到catch語句塊，並與catch語句塊逐一匹配，找到與之對應的處理程序，其餘的catch語句塊將不會被執行，而try語句塊中，出現異常以後的語句也不會被執行，catch語句塊執行完後，執行finally語句塊裏的語句，最後執行finally語句塊後的語句；

七拋出異常

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

1. throws拋出異常

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

throws語句用在方法定義時聲明該方法要拋出的異常類型，若是拋出的是Exception異常類型，則該方法被聲明爲拋出全部的異常。多個異常可以使用逗號分割。throws語句的語法格式爲：

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

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

public class TestException4 { 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()方法拋出的異常！");// 輸出異常信息 } } }

輸出：

pop()方法拋出的異常

使用throws關鍵字將異常拋給調用者後，若是調用者不想處理該異常，能夠繼續向上拋出，但最終要有可以處理該異常的調用者。
pop方法沒有處理異常NegativeArraySizeException，而是由main函數來處理。

Throws拋出異常的規則：

若是是不可查異常（unchecked exception），即Error、RuntimeException或它們的子類，那麼能夠不使用throws關鍵字來聲明要拋出的異常，編譯仍能順利經過，但在運行時會被系統拋出；
若是是任何可查異常（checked exception），必須進行聲明處理。即若是一個方法可能出現可查異常，要麼用try-catch語句捕獲，要麼用throws子句聲明將它拋出，不然會致使編譯錯誤；
僅當拋出了異常，該方法的調用者才必須處理或者從新拋出該異常。當方法的調用者無力處理該異常的時候，應該繼續拋出，而不是囫圇吞棗；
調用方法必須遵循任何可查異常的處理和聲明規則。若覆蓋一個方法，則不能聲明與覆蓋方法不一樣的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類；

例如：

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

2. 使用throw拋出異常

throw老是出如今函數體中，用來拋出一個Throwable類型的異常。程序會在throw語句後當即終止，它後面的語句執行不到，而後在包含它的全部try塊中（可能在上層調用函數中）從裏向外尋找含有與其匹配的catch子句的try塊。
咱們知道，異常是異常類的實例對象，咱們能夠建立異常類的實例對象經過throw語句拋出。該語句的語法格式爲：

throw new exceptionname(xx);

例如拋出一個IOException類的異常對象：

throw new IOException(xx);

要注意的是，throw 拋出的只可以是可拋出類Throwable 或者其子類的實例對象。下面的操做是錯誤的：

throw new String("exception");

這是由於String 不是Throwable 類的子類。

若是拋出了檢查異常，則還應該在方法頭部聲明方法可能拋出的異常類型，該方法的調用者應該處理拋出的異常；

public class TestException5 {
	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 =-1;
		
		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;
	}
}

若是調用者不處理該異常，全部方法都層層上拋獲取的異常，最終JVM會進行處理，處理也很簡單，就是打印異常消息和堆棧信息；

public class TestException5 {
	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[]) throws MyException  { // 主方法
		int  a =3;
		int  b =-1;
		
		quotient(a,b);
	
	}
 
}
class MyException extends Exception { // 建立自定義異常類
	
	String message; // 定義String類型變量
	
	public MyException(String ErrorMessagr) { // 父類方法
		message = ErrorMessagr;
	}
 
	public String getMessage() { // 覆蓋getMessage()方法
		return message;
	}
}

輸出以下：

Exception in thread "main" MyException: 除數不能是負數！
	at TestException5.quotient(TestException5.java:4)
	at TestException5.main(TestException5.java:12)

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

若是調用quotient(5,0)，將會因「除數爲0」錯誤引起ArithmeticException異常，屬於運行時異常類，由Java運行時系統自動拋出，quotient（）方法沒有捕捉ArithmeticException異常，Java運行時系統將沿方法調用棧查到main方法，將拋出的異常上傳至quotient（）方法的調用者。

三、Throwable類中的經常使用方法

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

getCause()：返回拋出異常的緣由，若是 cause 不存在或未知，則返回 null；
getMeage()：返回異常的消息信息；
printStackTrace()：對象的堆棧跟蹤輸出至錯誤輸出流，做爲字段 System.err 的值；
printStackTrace(System.out)：對象的堆棧跟蹤輸出系統輸出流，即在控制檯顯示；
fillInStackTrace()：有時但願把剛捕獲的異常從新拋出異常時，會使用該函數，主要用來把調用棧信息更新爲當前異常拋出點的棧信息。好比：throw (Exception)e.fillInStackTrace()；

有時爲了簡單會忽略掉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

IOException：操做輸入流和輸出流時可能出現的異常；
EOFException：文件已結束異常；
FileNotFoundException ：文件未找到異常；

3. 其餘

ClassCastException ：類型轉換異常類；
ArrayStoreException ：數組中包含不兼容的值拋出的異常；
SQLException：操做數據庫異常類；
NoSuchFieldException：字段未找到異常；
NoSuchMethodException：方法未找到拋出的異常；
NumberFormatException：字符串轉換爲數字拋出的異常；
StringIndexOutOfBoundsException：字符串索引超出範圍拋出的異常；
IllegalAccessException：不容許訪問某類異常；
InstantiationException：當應用程序試圖使用Class類中的newInstance()方法建立一個類的實例，而指定的類對象沒法被實例化時，拋出該異常；

九自定義異常

使用Java內置的異常類能夠描述在編程時出現的大部分異常狀況。除此以外，用戶還能夠自定義異常，用戶自定義異常類，只需繼承Exception類便可。
在程序中使用自定義異常類，大致可分爲如下幾個步驟。
（1）建立自定義異常類。
（2）在方法中經過throw關鍵字拋出異常對象。
（3）若是在當前拋出異常的方法中處理異常，可使用try-catch語句捕獲並處理；不然在方法的聲明處經過throws關鍵字指明要拋出給方法調用者的異常，繼續進行下一步操做。
（4）在出現異常方法的調用者中捕獲並處理異常。

參考文獻：

[1]深刻理解java異常處理機制(轉載)