?

java異常處理機制

1:什么是異常?
異常(Exception)也叫例外。在Java編程語言中，異常就是程序在運行過程中由于硬件設備問題、軟件設計錯誤、缺陷等導致的程序錯誤。在軟件開發過程中，很多情況都將導致異常的產生，例如：
(1)?想打開的文件不存在；
(2)?網絡連接中斷；
(3)?操作數超出預定范圍；
(4)?正在裝載的類文件丟失；
(5)?訪問的數據庫打不開；
可見，在程序中產生異常的現象是非常普遍的。在Java編程語言中，對異常的處理有非常完備的機制。異常本身作為一個對象，產生異常就是產生一個異常對象。這個對象可能由應用程序本身產生，也?

可能由?Java?虛擬機產生，這取決于產生異常的類型。該異常對象中包括了異常事件的類型以及發生異常時應用程序目前的狀態和調用過程。請看下面產生異常的例子
文件操作將產生異常
//?Exception1.java
import?java.io.*;
class?Exception1?{
?p?lic?static?void?main(String?args[]){
??FileInputStream?fis?=new??FileInputStream("text.txt");
??int?b;
??while((b=fis.read())!=-1)?{
???System.out.print(b);
??}
??fis.close();
?}
}
當編譯這個程序時，屏幕上會輸出下面的信息：
D:\user\chap08>javac?Exception1.java
Exception1.java:5:?unreported?exception?java.io.FileNotFoundException;?must?be?caught?or?declared?to?be?thrown
??FileInputStream?fis?=?new??FileInputStream("text.txt");
^
Exception1.java:7:?unreported?exception?java.io.IOException;?must?be?caught?or?declared?to?be?thrown
??while((b=fis.read())!=-1)?{
???^
Exception1.java:10:?unreported?exception?java.io.IOException;?must?be?caught?ordeclared?to?be?thrown
???fis.close();
^
3?errors

數組下標超界的例子
//Exception2.java
p?lic?class?Exception2{
?p?lic?static?void?main?(String?args[])?{?
??String?langs?[]?=?{"Java","Visaul?Basic","C++"};
??int?i?=?0;
??while?(i?<?4)?{
???System.out.println?(langs[i]);
???i++;
??}
?}
}?
程序的編譯和運行結果如下：
D:\user\chap08>javac?Exception2.java??
D:\user\chap08>java??Exception2
Java
Visaul?Basic
C++
Exception?in?thread?"main"?java.lang.ArrayIndexOutOfBoundsException:?3
at?Exception2.main(Exception2.java:8)
上面的例子編譯可以通過，但運行時出現異常信息被拋出。在其循環被
執行四次之后，數組下標溢出，程序終止，并帶有錯誤信息，就象前面
所示的程序那樣。

被0除的例子
//?Exception3.java
class?Exception3{
??p?lic?static?void?main(String?args[]){
int?a=0;
System.out.println(5/a);
??}
}
我們編譯這個程序得到其字節碼文件，然后運行它，屏幕上的顯示如
下：
D:\user\chap08>javac?Exception3.java
D:\user\chap08>java??Exception3
Exception?in?thread?"main"?java.lang.ArithmeticException:?/?by?zero
at?Exception3.main(Exception3.java:5)
因為除數不能為0，所以在程序運行的時候出現了除以0溢出的異常事
件。

在上面的三個例子中，我們都遇到了異常。屏幕上所顯示的信息
java.io.IOException、
java.io.FileNotFoundException、
java.lang.ArrayIndexOutOfBoundsException
以及java.lang.ArithmeticException
分別指明了異常的類型以及異常所在的包。同時我們也可以看到，對
于某些異常，在程序中必須對它進行處理，否則編譯程序會指出錯誤
(如例1)。但對另一些異常，在程序中可以不做處理，而直接由運行時
系統來處理(如例3)。在下節中，我們將詳細了解這兩類異常，以及在
程序中如何處理這兩類異常。?

2?異常處理機制
(1)Java的異常處理機制:
在?Java?程序的執行過程中，如果出現了異常事件，就會生成一個異常對象。這個對象可能是由正在運行的方法生成，也可能由Java虛擬機生成，其中包含一些信息指明異常事件的類型以及當異常發生

時程序的運行狀態等。Java語言提供兩種處理異常的機制：
（1）捕獲異常
在Java程序運行過程中系統得到一個異常對象時，它將會沿著方法的調用棧逐層回溯，尋找處理這一異常的代碼。找到能夠處理這種類型異常的方法后，運行時系統把當前異常對象交給這個方法進行處

理，這一過程稱為捕獲(catch)異常。這是一種積極的異常處理機制。如果Java運行時系統找不到可以捕獲異常的方法，則運行時系統將終止，相應的Java程序也將退出。
（2）聲明拋棄異常
當Java程序運行時系統得到一個異常對象時，如果一個方法并不知道如何處理所出現的異常，則可在方法聲明時，聲明拋棄（throws）異常。

(2)異常類的類層次:
?前面已經提到，Java?是采用面向對象的方法來處理錯誤的，一個異常事件
是由一個異常對象來代表的。這些異常對象都對應于類java.lang.Throwable及
其子類。下面我們就來看一下異常類的層次。
?在?java類庫的每個包中都定義了自己的異常類，所有這些類都直接或間接
地繼承于類Throwable。圖1列舉了一些異常類并指明了它們的繼承關系。
?Java中的異常事件分為兩大類。一類繼承于類Error，它的繼承關系如下：
?java.lang.Object
?java.lang.Throwable?
?java.lang.Error
?常見的錯誤類有AnnotationFormatError,??AssertionError,??AWTError,??
LinkageError,?CoderMalfunctionError,?FactoryConfigurationError,ThreadDeath,
Virt?lMachineError,??TransformerFactoryConfigurationError等，包括動態鏈接
失敗、線程死鎖、圖形界面錯誤、虛擬機錯誤等，通常Java程序不應該捕獲這
類異常，也不會拋棄這種異常。

另外一類異常則繼承于類Exception，這是Java程序中所大量處理的異常。它
的繼承關系如下：
java.lang.Object
?java.lang.Throwable
??java.lang.Exception
常見異常類有：AclNotFoundException,?ApplicationException,?AWTException,?
BackingStoreException,?ClassNotFoundException,?
CloneNotSupportedException,?DataFormatException,?DestroyFailedException,?
ExecutionException,?PrintException,?GeneralSecurityException,?
InterruptedException,?InvalidPreferencesFormatException,??ParseException,?
RuntimeException,?SAXException,?SQLException,?TimeoutException,?
TransformerException,?UnsupportedCallbackException,?
UnsupportedLookAndFeelException,?URISyntaxException,?UserException,?
XAException,?XMLParseException,?XPathException??等
其中包括了運行時異常和非運行時異常。?

常見的運行時異常如下：

(1)?類型轉換異常ClassCastException
String?strName=new?string(“123”);
int?nNumber=(int)strName;??
(2)?數組超界異常ArrayIndexOutBoundsException
int[]?b=new?int[10];
b[10]=1000;
(3)?指定數組維數為負值異常NegativeArraySizeException
b[-1]=1001;
(4)?算術異常ArithmeticException
int?b=0;
a=500/b;
(5)?Java系統內部異常InternalException
JVM拋出的異常。
(6)?類型不符合異常IncompatibleTypeException
int?n=12345;
String?s=(String)n;??
(7)?內存溢出異常OutOfMemeoryException
(8)?沒有找到類定義異常NoClassDefFoundException
aClass?aa=new?aClas();?//但aClass類未定義。
(9)?空指針異常?NullPointerException
int?b[?];
b[0]=99;???//沒有實例化，就訪問，將產生空指針。

常見的非運行時異常如下：
(1)?ClassNotFoundException?：找不到類或接口所產生的異常
(2)?CloneNotSupportedException：使用對象的?clone?方法但無法執行?Cloneable?所產生的異常。
(3)?IllegalAccessException?：類定義不明確所產生的異常。例如：類不為?p?lic?，或是包含一個類定義在另一個類庫內。
(4)?IOException?：在一般情況下不能完成I/O操作所產生的異常。
(5)?EOFException:?打開文件沒有數據可以讀取所產生的異常
(6)?FileNotFoundException?:在文件系統中，找不到文件名稱或路徑所產生
(7)?InterruptedIOException:目前線程等待執行，另一線程中斷目前線程I/O運行所產生的異常
??在Sun公司提供的各種API包中，如java.io,java.net,java.awt等，都提供不同情況下可能產生的異常。由于異常的種類非常多，需要讀者實際運用中逐漸掌握。?

(3)Throwable類的常用方法:
java.lang.Throwable類是所有Error類和Exception類的父類，常用的方法有?：fillInStackTrace()?、getLocalizedMessage()?、getMessage()?、printStackTrace()、printStackTrace(PrintStream)?

、?????????????printStackTrace(PrintWriter)?、toString()。
(1)?p?lic?native?Throwable?fillInStackTrace()
填寫執行堆棧跟蹤信息。?該方法在應用程序重新拋出錯誤或異常時有用。例如：?
?try?{
?a?=?b?/?c;
?}?catch(ArithmeticThrowable?e)?{
?a?=?Number.MAX_VAL;
?throw?e.fillInStackTrace();
?}
(2)?p?lic?String?getLocalizedMessage()
生成該?Throwable?的本地化描述。?子類可能會覆蓋該方法以便產生一個特定于本地的消息。?對于未覆蓋該方法的子類，缺省地返回調用?getMessage()?的結果。?
(3)?p?lic?String?getMessage()
返回該?throwable?對象的詳細信息。如果該對象沒有詳細信息則返回null。?
(4)?p?lic?void?printStackTrace()
把該?Throwable?和它的跟蹤情況打印到標準錯誤流。
(5)?p?lic?void?printStackTrace(PrintStream?s)
把該?Throwable?和它的跟蹤情況打印到指定打印流。?
(6)?p?lic?void?printStackTrace(PrintWriter?s)
把該?Throwable?和它的跟蹤情況打印到指定打印流。
(7)?p?lic?String?toString()
返回該?throwable?對象的簡短字符串描述。?

3?異常的處理
(1)捕獲異常try-catch-finally:
一個方法中如果對某種類型的異常對象提供了相應的處理代碼，則這個方法可捕獲該種異常。捕獲異常是通過try-catch-finally語句實現的。其語法為：
try{　??......　　}catch(?ExceptionName1?e?){　　　......?　　}catch(?ExceptionName2?e?){　　　......　　　}　　......　　}finally{　　......　}　　
1、try
捕獲異常的第一步是用try{…}選定捕獲異常的范圍，由try所限定的代碼塊中的語句在執行過程中可能會生成異常對象并拋棄。
2、catch　　
每個try代碼塊可以伴隨一個或多個catch語句，用于處理try代碼塊中所生成的異常事件。catch語句只需要一個形式參數來指明它所能夠捕獲的異常類型,這個類必須是Throwable的子類,運行時系統通過

參數值把被拋棄的異常對象傳遞給catch塊。
catch塊中的代碼用來對異常對象進行處理，與訪問其它對象一樣，可以訪問一個異常對象的變量或調用它的方法。getMessage(?)是類Throwable所提供的方法，用來得到有關異常事件的信息，類

Throwable還提供了方法printStackTrace(?)用來跟蹤異常事件發生時執行堆棧的內容。例如：　　
try{　　　　......　　}
?catch(?FileNotFoundException?e?)
?{　　　　
??System.out.println(?e?);　　　
??System.out.println(?"message:?"+e.getMessage()?
?);　　　
??e.printStackTrace(?System.out?);　　
?}catch(?IOException?e?)
?{　　　
??System.out.println(?e?);　　
?}
3、catch?語句的順序　捕獲異常的順序和catch語句的順序有關，當捕獲到一個異常時，剩下的catch語句就不再進行匹配。因此，在安排catch語句的順序時，首先應該捕獲最特殊的異常，然后再逐漸

一般化。也就是一般先安排子類，再安排父類。例如上面的程序如果安排成如下的形式：
　try{　　　　......　　　}
?catch(IOException?e?)
?{　　　　
??System.out.println(?e?);　　　
??System.out.println(?"message:?"+e.getMessage()?);　　　
??e.printStackTrace(?System.out?);
?}catch(FileNotFoundException?e?)
?{　　　　
??System.out.println(?e?);　　
?}
由于第一個catch語句首先得到匹配，第二個catch語句將不會被執行。編譯時將出現“catch?not?reached”的錯誤。
4、finally
捕獲異常的最后一步是通過finally語句為異常處理提供一個統一的出口，使得在控制流轉到程序的其它部分以前，能夠對程序的狀態作統一的管理。一般是用來關閉文件或釋放其他的系統資源。雖然

finally作為try-catch-finally結構的一部分，但在程序是可選的，也就是說可以沒有?finally語句。如果存在finally語句，不論try塊中是否發生了異常，是否執行過catch?語句，都要執行finally語

句。
另外，try-catch-finally可以嵌套。

(2)聲明拋出異常:
如果在一個方法中生成了一個異常，但是這一方法并不確切地知道該如何對這一異常事件進行處理，這時，該方法就應該聲明拋棄異常，使得異常對象可以從調用棧向后傳播，直到有合適的方法捕獲它

為止。?????聲明拋棄異常是在一個方法聲明中的throws子句中指明的。例如：　　p?lic?int?read?()?throws?IOException{　　……
??}
??throws子句中同時可以指明多個異常，之間由逗號隔開。例如：?
??p?lic?static?void?main(String?args[])?throws
??IOException,IndexOutOfBoundsException?{
??……
??}
最后，我們再次強調，對于非運行時例外，如前例中的IOException等，程序中必須要作出處理，或者捕獲，或者聲明拋棄。而對于運行時例外，如前例中的ArithmeticException，

IndexOutOfBoundsException，則可以不做處理
拋棄異常的例子（對之前的進行改進）
//?Exception4.java
import?java.io.*;
p?lic?class?Exception4{
?p?lic?static?void?main(String?args[])throws?FileNotFoundException,IOException{
FileInputStream?fis=new?FileInputStream(“text.txt”);
int?b;
while((b=fis.read())!=-1){
??System.out.print(b);
?}
??fis.close();
?}
}

捕獲異常的例子（對之前的進行改進）
import?java.io.*;
p?lic?class?Exception5{
p?lic?static?void?main(String?args[])?{
?try{
???FileInputStream?fis=new?FileInputStream(“text.txt”);
int?b;
while((b=fis.read())!=-1){
System.out.print(b);
}
??fis.close();
?}catch(FileNotFoundException?e)
??{　　　　????
???System.out.println(?e?);　　　　
??System.out.println(?"message:?"+e.getMessage()?);　　　??????e.printStackTrace(?System.out?);　????　
??}catch(IOException?e)
???{　　　　????
System.out.println(?e?);　
??}?
}?

(3)拋出異常:
拋出異常就是產生異常對象的過程，首先要生成異常對象，異常或者由虛擬機生成，或者由某些類的實例生成，也可以在程序中生成。在方法中，拋出異常對象是通過throw語句實現的。　　
例如：　　
?IOException?e=new?IOException();
?throw?e?;
可以拋出的異常必須是Throwable或其子類的實例。下面的語句在編譯時將會產生語法錯誤：
throw?new?String("throw?anything");
自定義異常類必須是Throwable的直接或間接子類。
顯示拋出異常詳細情況的例子
//Exception6.java
p?lic?class?Exception6?{?
p?lic?static?void?main(String[]?args)?{??
try?{??
?throw?new?Exception("My?Exception");?????}?catch?(Exception?e)
???{
???System.err.println("Caught?Exception");???
???System.err.println("getMessage():"?+?e.getMessage());??
???System.err.println("getLocalizedMessage():"+?e.getLocalizedMessage());??????????
???System.err.println("toString():"?+?e);?????????
???System.err.println("printStackTrace():");????????????e.printStackTrace();
???}?
}
}?
程序運行結果如下:
d:\user\chap08>java?Exception6
Caught?Exception
getMessage():My?Exception
getLocalizedMessage():My?Exception
toString():java.lang.Exception:?My?Exception
printStackTrace():
java.lang.Exception:?My?Exception
?at?Exception6.main(Exception6.java:5)

try-catch-finally嵌套的例子
class?MyoneException?extends?Exception?{
}
p?lic?class?TryInbed?{
???p?lic?static?void?main(String[]?args)?{
??System.out.println("Entering?first?try?block");
??try?{
?System.out.println("Entering?second?try?block");
?try?{
throw?new?MyoneException();
?}?finally?{
System.out.println("finally?in?2nd?try?block");
?}//try-catch-finally嵌套在try限定的范圍內。
??}?catch?(MyoneException?e)?{
?System.err.println("Caught?MyoneException?in?1st?try?block");
??}?finally?{
?System.err.println("finally?in?1st?try?block");
??}
???}
}
程序運行結果如下：
Entering?first?try?block
Entering?second?try?block
finally?in?2nd?try?block
Caught?MyoneException?in?1st?try?block
finally?in?1st?try?block

(4)創建用戶異常類:
如果?Java?提供的系統異常類型不能滿足程序設計的需求，我們可以設計自己的異常類型。
從?Java?異常類的結構層次可以看出，Java?異常的公共父類為?Throwable?。在程序運行中可能出現兩種問題：一種是由硬件系統或JVM導致的故障，?Java?定義該故障為?Error?。這類問題用戶程序不

能夠處理的。另外一種問題是程序運行錯誤，Java?定義為?Exception。這種情況下，可以通過程序設計的調整來實現異常處理。
因此，用戶定義的異常類型必須是?Throwable?的直接或間接子類。Java?推薦用戶的異常類型以?Exception?為直接父類。創建用戶異常的方法如下：
?class?UserException?extends?Exception{
??UserException(){
?super();
??……?//其它語句
??}??
?}
我們在使用異常時，有以下幾點建議需要注意：
(1)?對于運行時例外，如果不能預測它何時發生，程序可以不做處理，而是讓Java虛機去處理它。
(2)?如果程序可以預知運行時例外可能發生的地點和時間，則應該在程序中進行處理，而不應簡單地把它交給運行時系統。(3)在自定義異常類時，如果它所對應的異常事件通常總是在運行時產生的，而

且不容易預測它將在何時、何處發生，則可以把它定義為運行時例外，否則應定義為非運行時例外。

用戶定義的異常類的使用
//?Exceptionjava
class?MyotherException?extends?Exception?{??//用戶定義的異常
???p?lic?MyotherException()?{??
???}
???p?lic?MyotherException(String?msg)?{
??super(msg);
???}
}

p?lic?class?Exception8?{
???p?lic?static?void?f()?throws?MyotherException?{
??System.out.println("Throwing?MyotherException?from?f()");
??throw?new?MyotherException();
???}
???p?lic?static?void?g()?throws?MyotherException?{
??System.out.println("Throwing?MyotherException?from?g()");
??throw?new?MyotherException("Originated?in?g()");
???}
???p?lic?static?void?main(String[]?args)?{
??try?{?
???f();
??}catch?(MyotherException?e)?{
e.printStackTrace();
??}
??try?{??
???g();
??}?catch?(MyotherException?e)?{
e.printStackTrace();
??}
?}
}
程序的運行結果如下：
Throwing?MyotherException?from?f()
Throwing?MyotherException?from?g()
MyotherException
at?Exceptionf(Exceptionjava:13)
at?Exceptionmain(Exceptionjava:21)
MyotherException:?Originated?in?g()
at?Exceptiong(Exceptionjava:17)
at?Exceptionmain(Exceptionjava:26)

?

轉載于:https://blog.51cto.com/7825719/1283781

總結

以上是生活随笔為你收集整理的黑马程序员_java异常处理机制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。