Java異常類
原文出自：http://blog.csdn.net/hguisu/article/details/6155636 在原文的基礎上做優化和編輯。
異常指不期而至的各種狀況，如：文件找不到、網絡連接失敗、非法參數等。異常是一個事件，它發生在程序運行期間，幹擾了正常的指令流程。Java通 過API中Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是對象，是Throwable子類的實例，描述了出現在一段編碼中的 錯誤條件。當條件生成時，錯誤將引發異常。
Java異常類層次結構圖：
在 Java 中，所有的異常都有一個共同的祖先 Throwable（可拋出）。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。
Throwable：
Error（錯誤）:是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。
這些錯誤表示故障發生於虛擬機自身、或者發生在虛擬機試圖執行應用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的（因為不知道什麽時候會出現這類問題，不好指定同時也沒有定義
Exception（異常）:是程序本身可以處理的異常(很多錯誤提前可以預知如除數為0就會報錯)。
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子句聲明拋出它，也會編譯通過( 如果所有方法都層層上拋獲取的異常，最終JVM會進行處理，處理也很簡單，就是打印異常消息和堆棧信息。如果拋出的是Error或RuntimeException，則該方法的調用者可選擇處理該異常)。
非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬於Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。
Java中的異常處理機制
在 Java 應用程序中，異常處理機制為：拋出異常，捕捉異常。
拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象並交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼並執行。
捕獲異常：在方法拋出異常之後，運行時系統將轉為尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即為合適 的異常處理器。運行時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合適異常處理器的方法並執行。當運行時系統遍歷調用棧而未找到合適 的異常處理器，則運行時系統終止。同時，意味著Java程序的終止。
對於運行時異常、錯誤或可查異常，Java技術所要求的異常處理方式有所不同。
由於運行時異常（RuntimeException及其子類）的不可查性，為了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程序忽略運行時異常（如：“除數為0”等ArithmeticException，是RuntimException的子類。而運行時異常將由運行時系統自動拋出，不需要使用throw語句）。
對於方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因為，大多數Error異常屬於永遠不能被允許發生的狀況，也屬於合理的應用程序不該捕捉的異常（在編寫程序時不需要考慮Error）。
對於所有的可查異常（除了RuntimeException及其子類），Java規定：一個方法必須捕捉，或者聲明拋出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常，因為Java編譯器會檢查它，也就是說，當程序中可能出現這類異常，要麽用try-catch語句捕獲它，要麽用throws子句聲明拋出它，否則編譯不會通過。
能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由於自身語句所引發並拋出的異常，也可能是由某個調用的方法或者Java運行時 系統等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所拋出的異常。簡單地說，異常總是先被拋出，後被捕捉的。
任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。
1.從方法中拋出的任何異常都必須使用throws子句。
2.捕捉異常通過try-catch語句或者try-catch-finally語句實現。
3.總體來說，Java規定：對於可查異常必須捕捉、或者聲明拋出(throw)。允許忽略不可查的RuntimeException和Error。
例1：
package cn.czbk.no9; public class ExceprtionTest { /** * @param args */ public static void main(String[] args) { int a=6; int b=0; /** * 除數為0,屬於RuntimeException,屬於不可查異常 * 編譯器不會對其做檢查。 * 運行時異常由系統jvm自動拋出不需要主動throw */ int c=a/b; System.out.println(c); } }
運行時異常由系統即JVM主動拋出不需要手動throw
那麽我們要讓程序正常通過，就要處理這個運行時異常。
package cn.czbk.no9; public class ExceprtionTest { /** * @param args */ public static void main(String[] args) { int a=6; int b=2; /** * 除數為0,屬於RuntimeException,屬於不可查異常 * 編譯器不會對其做檢查。 * 運行時異常由系統jvm自動拋出不需要主動throw */ try { if(b==0){ //在運行過程中出現的異常都是屬於上面講的異常類的實例 throw new ArithmeticException(); //由於是RuntimeException所以可以不用顯示拋出 }else{ System.out.println("a/b="+(a/b)); } } catch (ArithmeticException e) { // TODO: handle exception System.out.println("除數不能為0"); } System.out.println("程序正常結束！"); } }
try－catch-finally語句
try { // 可能會發生異常的程序代碼 } catch (Type1 id1) { // 捕獲並處理try拋出的異常類型Type1 } catch (Type2 id2) { // 捕獲並處理try拋出的異常類型Type2 } finally { // 無論是否發生異常，都將執行的語句塊 }
實例：
package cn.czbk.no9; import java.util.Scanner; public class ExceptionTest1 { public static void main(String[] args) { int[] intArray = new int[4]; int a = 20; int c=0; //數組初始化賦值 for (int i = 0; i <= 3; i++) { intArray[i] = i; } //根據輸入的值判斷循環次數 Scanner in=new Scanner(System.in); String text=in.nextLine(); //將輸入的String轉為Int int x=Integer.parseInt(text); for (int i = x; i >= 0; i--) { //將不可查異常即RuntimeException進行捕獲處理 try { int b = intArray[i]; c=a/b; } /** * 如果拋出的異常對象屬於catch子句的異常類，或者屬於該異常類的子類，則認為生成的異常對象與catch塊捕獲的異常類型相匹配。 * 一旦某個catch捕獲到匹配的異常類型，將進入異常處理代碼。 * 一經處理結束，就意味著整個try-catch語句結束。 * 其他的catch子句不再有匹配和捕獲異常類型的機會。 * 對於有多個catch子句的異常程序而言，應該盡量將捕獲底層異常類的catch子 句放在前面， * 同時盡量將捕獲相對高層的異常類的catch子句放在後面。 * 否則，捕獲底層異常類的catch子句將可能會被屏蔽。 */ catch (ArrayIndexOutOfBoundsException e) { // TODO: handle exception System.out.println("數組下標越界，原數組中沒有intArray["+i+"]"); } catch (ArithmeticException e) { // TODO: handle exception System.out.println("intArray[" + i + "]" + "除數不能為0"); } catch (Exception e) { // TODO: handle exception System.out.println("其他未想到的運行時異常"); } finally { System.out.println("i為"+i+"計算結果 a/b="+a+"/"+intArray[i]+"="+c); } } } }
總結：
try 塊：用於捕獲異常。其後可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。
catch 塊：用於處理try捕獲到的異常。
finally 塊：無論是否捕獲或處理異常，finally塊裏的語句都會被執行。當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執行。在以下4種特殊情況下，finally塊不會被執行：
1）在finally語句塊中發生了異常。
2）在前面的代碼中用了System.exit()退出程序。
3）程序所在的線程死亡。
4）關閉CPU。
拋出異常
1. throws拋出異常
methodname throws Exception1,Exception2,..,ExceptionN { }
方法名後的throws Exception1,Exception2,...,ExceptionN 為聲明要拋出的異常列表。當方法拋出異常列表的異常時，方法將不對這些類型及其子類類型的異常作處理，而拋向調用該方法的方法，由他去處理。例如：
Throws拋出異常的規則：
1) 如果是不可查異常（unchecked exception），即Error、RuntimeException或它們的子類，那麽可以不使用throws關鍵字來聲明要拋出的異常，編譯仍能順利通過，但在運行時會被系統拋出。
2）必須聲明方法可拋出的任何可查異常（checked exception）。即如果一個方法可能出現受可查異常，要麽用try-catch語句捕獲，要麽用throws子句聲明將它拋出，否則會導致編譯錯誤
3)僅當拋出了異常，該方法的調用者才必須處理或者重新拋出該異常。當方法的調用者無力處理該異常的時候，應該繼續拋出，而不是囫圇吞棗。
4）調用方法必須遵循任何可查異常的處理和聲明規則。若覆蓋一個方法，則不能聲明與覆蓋方法不同的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類。
2. 使用throw拋出異常
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。
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，則該方法的調用者可選擇處理該異常。
package cn.czbk.no9; public class ExceptionTest3 { public void pop() throws MyException{ String s="測試用"; throw new MyException(s); } public static void main(String[] args) throws MyException{ ExceptionTest3 et=new ExceptionTest3(); et.pop(); } } class MyException extends Exception{ String message; public MyException(String errorMessage){ message=errorMessage; } public String getMessage(){ return message; } }
在main函數繼續拋出的話會在運行後會顯示如下內容
如果不拋出而是選擇處理的話如下所示
package cn.czbk.no9; public class ExceptionTest3 { public void pop() throws MyException{ String s="測試用"; throw new MyException(s); } public static void main(String[] args){ ExceptionTest3 et=new ExceptionTest3(); try { et.pop(); } catch (MyException e) { // TODO: handle exception e.getPrintMessage(); } } } class MyException extends Exception{ String message; public MyException(String errorMessage){ message=errorMessage; } public void getPrintMessage(){ System.out.println(message); } }
4.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子類:
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()方法創建一個類的實例，而指定的類對象無法被實例化時，拋出該異常
Java異常類