1. 引子
try…catch…finally恐怕是大家再熟悉不過的語句了，而且感覺用起來也是很簡單，邏輯上似乎也是很容易了解。不過，我親自體驗的“教訓”告訴我，這個東西可不是想象中的那麼簡單、聽話。不信？那你看看下面的代碼，“猜猜”它執行後的結果會是什麼？不要往後看答案、也不許執行代碼看真正答案哦。如果你的答案是正确，那麼這篇文章你就不用浪費時間看啦。
<span style="background-color: rgb(255, 255, 255);">package test;
public class testexception {
public testexception() {
}
boolean testex() throws exception {
boolean ret = true;
try {
ret = testex1();
} catch (exception e) {
system.out.println("testex, catch exception");
ret = false;
throw e;
} finally {
system.out.println("testex, finally; return value=" + ret);
return ret;
}
boolean testex1() throws exception {
ret = testex2();
if (!ret) {
return false;
}
system.out.println("testex1, at the end of try");
system.out.println("testex1, catch exception");
system.out.println("testex1, finally; return value=" + ret);
boolean testex2() throws exception {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
system.out.println("i=" + i);
return true;
system.out.println("testex2, catch exception");
system.out.println("testex2, finally; return value=" + ret);
public static void main(string[] args) {
testexception testexception1 = new testexception();
testexception1.testex();
e.printstacktrace();
}
</span>
你的答案是什麼？是下面的答案嗎？
i=2
i=1
testex2, catch exception
testex2, finally; return value=false
testex1, catch exception
testex1, finally; return value=false
testex, catch exception
testex, finally; return value=false
如果你的答案真的如上面所說，那麼你錯啦。^_^，那就建議你仔細看一看這篇文章或者拿上面的代碼按各種不同的情況修改、執行、測試，你會發現有很多事情不是原來想象中的那麼簡單的。現在公布正确答案：
注意說明：
finally語句塊不應該出現 應該出現return。上面的return ret最好是其他語句來處理相關邏輯。
2.java異常
異常指不期而至的各種狀況，如：檔案找不到、網絡連接配接失敗、非法參數等。異常是一個事件，它發生在程式運作期間，幹擾了正常的指令流程。java通
過api中throwable類的衆多子類描述各種不同的異常。因而，java異常都是對象，是throwable子類的執行個體，描述了出現在一段編碼中的 錯誤條件。當條件生成時，錯誤将引發異常。
java異常類層次結構圖：
圖1 java異常類層次結構圖
在 java 中，所有的異常都有一個共同的祖先 throwable（可抛出）。throwable 指定代碼中可用異常傳播機制通過 java 應用程式傳輸的任何問題的共性。
throwable： 有兩個重要的子類：exception（異常）和 error（錯誤），二者都是 java 異常處理的重要子類，各自都包含大量子類。
error（錯誤）:是程式無法處理的錯誤，表示運作應用程式中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運作時 jvm（java 虛拟機）出現的問題。例如，java虛拟機運作錯誤（virtual machineerror），當 jvm 不再有繼續執行操作所需的記憶體資源時，将出現
outofmemoryerror。這些異常發生時，java虛拟機（jvm）一般會選擇線程終止。
。這些錯誤表示故障發生于虛拟機自身、或者發生在虛拟機試圖執行應用時，如java虛拟機運作錯誤（virtual machineerror）、類定義錯誤（noclassdeffounderror）等。這些錯誤是不可查的，因為它們在應用程式的控制和處理能力之 外，而且絕大多數是程式運作時不允許出現的狀況。對于設計合理的應用程式來說，即使确實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 java中，錯誤通過error的子類描述。
exception（異常）:是程式本身可以處理的異常。
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子句聲明抛出它，也會編譯通過。
非運作時異常 （編譯異常）：是runtimeexception以外的異常，類型上都屬于exception類及其子類。從程式文法角度講是必須進行處理的異常，如果不處理，程式就不能編譯通過。如ioexception、sqlexception等以及使用者自定義的exception異常，一般情況下不自定義檢查異常。
4.處理異常機制
在 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。
在java中，異常通過try-catch語句捕獲。其一般文法形式為：
try {
// 可能會發生異常的程式代碼
} catch (type1 id1){
// 捕獲并處置try抛出的異常類型type1
catch (type2 id2){
//捕獲并處置try抛出的異常類型type2
關鍵詞try後的一對大括号将一塊可能發生異常的代碼包起來，稱為監控區域。java方法在運作過程中出現異常，則建立異常對象。将異常抛出監控區域之 外，由java運作時系統試圖尋找比對的catch子句以捕獲異常。若有比對的catch子句，則運作其異常處理代碼，try-catch語句結束。
比對的原則是：如果抛出的異常對象屬于catch子句的異常類，或者屬于該異常類的子類，則認為生成的異常對象與catch塊捕獲的異常類型相比對。
例1 捕捉throw語句抛出的“除數為0”異常。
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。
程式正常結束。
例1 在try監控區域通過if語句進行判斷，當“除數為0”的錯誤條件成立時引發arithmeticexception異常，建立 arithmeticexception異常對象，并由throw語句将異常抛給java運作時系統，由系統尋找比對的異常處理器catch并運作相應異 常處理代碼，列印輸出“程式出現異常，變量b不能為0。”try-catch語句結束，繼續程式流程。
事實上，“除數為0”等arithmeticexception，是runtimexception的子類。而運作時異常将由運作時系統自動抛出，不需要使用throw語句。
例2 捕捉運作時系統自動抛出“除數為0”引發的arithmeticexception異常。
} catch (arithmeticexception e) {
程式正常結束。
例2 中的語句：
system.out.println("a/b的值是：" + a/b);
在運作中出現“除數為0”錯誤，引發arithmeticexception異常。運作時系統建立異常對象并抛出監控區域，轉而比對合适的異常處理器catch，并執行相應的異常處理代碼。
由于檢查運作時異常的代價遠大于捕捉異常所帶來的益處，運作時異常不可查。java編譯器允許忽略運作時異常，一個方法可以既不捕捉，也不聲明抛出運作時異常。
例3 不捕捉、也不聲明抛出運作時異常。
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異常和數組下标越界異常。
int[] intarray = new int[3];
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數組下标越界異常。");
system.out.println("除數為0異常。");
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子句應該放在 最後面，否則可能會屏蔽其後的特定異常處理或引起編譯錯誤。
try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現異常，都應當執行的内容。try-catch-finally語句的一般文法形式為：
try {
} catch (type1 id1) {
// 捕獲并處理try抛出的異常類型type1
} catch (type2 id2) {
// 捕獲并處理try抛出的異常類型type2
} finally {
// 無論是否發生異常，都将執行的語句塊
例5 帶finally子句的異常處理程式。
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 !!!
數組下标越界異常
在例5中，請特别注意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。
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 塊中抛出一個未處理的異常；計算機斷電、失火、或遭遇病毒攻擊。
1)當try沒有捕獲到異常時：try語句塊中的語句逐一被執行，程式将跳過catch語句塊，執行finally語句塊和其後的語句；
2)當try捕獲到異常，catch語句塊裡沒有處理此異常的情況：當try語句塊裡的某條語句出現異常時，而沒有處理此異常的catch語句塊時，此異常将會抛給jvm處理，finally語句塊裡的語句還是會被執行，但finally語句塊後的語句不會被執行；
3)當try捕獲到異常，catch語句塊裡有處理此異常的情況：在try語句塊中是按照順序來執行的，當執行到某一條語句出現異常時，程式将跳到catch語句塊，并與catch語句塊逐一比對，找到與之對應的處理程式，其他的catch語句塊将不會被執行，而try語句塊中，出現異常之後的語句也不會被執行，catch語句塊執行完後，執行finally語句塊裡的語句，最後執行finally語句塊後的語句；
圖示try、catch、finally語句塊的執行：
圖2 圖示try、catch、finally語句塊的執行
任何java代碼都可以抛出異常，如：自己編寫的代碼、來自java開發環境包中代碼，或者java運作時系統。無論是誰，都可以通過java的throw語句抛出異常。從方法中抛出的任何異常都必須使用throws子句。
如果一個方法可能會出現異常，但沒有能力處理這種異常，可以在方法聲明處用throws子句來聲明抛出異常。例如汽車在運作時可能會出現故障，汽車本身沒辦法處理這個故障，那就讓開車的人來處理。
throws語句用在方法定義時聲明該方法要抛出的異常類型，如果抛出的是exception異常類型，則該方法被聲明為抛出所有的異常。多個異常可使用逗号分割。throws語句的文法格式為：
methodname throws exception1,exception2,..,exceptionn
{
方法名後的throws exception1,exception2,...,exceptionn 為聲明要抛出的異常清單。當方法抛出異常清單的異常時，方法将不對這些類型及其子類類型的異常作處理，而抛向調用該方法的方法，由他去處理。例如：
import java.lang.exception;
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 {
//合法，聲明抛出exception，ioexception是exception的子類
void method4()throws exception {
//合法，捕獲ioexception
void method5(){
try{
method1();
}catch(ioexception e){…}
//編譯錯誤，必須捕獲或聲明抛出exception
void method6(){
try{
}catch(ioexception e){throw new exception();}
//合法，聲明抛出exception
void method7()throws exception{
}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 test;
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;
4.3 異常鍊
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語句的順序不可掉換。
注意：catch關鍵字後面括号中的exception類型的參數e。exception就是try代碼塊傳遞給catch代碼塊的變量類型，e就是變量名。catch代碼塊中語句"e.getmessage();"用于輸出錯誤性質。通常異常處理常用3個函數來擷取異常的有關資訊:
getcause()：傳回抛出異常的原因。如果 cause 不存在或未知，則傳回 null。
getmeage()：傳回異常的消息資訊。
printstacktrace()：對象的堆棧跟蹤輸出至錯誤輸出流，作為字段 system.err 的值。
有時為了簡單會忽略掉catch語句後的代碼，這樣try-catch語句就成了一種擺設，一旦程式在運作過程中出現了異常，就會忽略處理異常，而錯誤發生的原因很難查找。
5.java常見異常
在java中提供了一些異常用來描述經常發生的錯誤，對于這些異常，有的需要程式員進行捕獲處理或聲明抛出，有的是由java虛拟機自動進行捕獲處理。java中常見的異常類:
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 非法參數異常
ioexception：操作輸入流和輸出流時可能出現的異常。 eofexception 檔案已結束異常 filenotfoundexception 檔案未找到異常
classcastexception 類型轉換異常類 arraystoreexception 數組中包含不相容的值抛出的異常 sqlexception 操作資料庫異常類 nosuchfieldexception 字段未找到異常 nosuchmethodexception 方法未找到抛出的異常 numberformatexception 字元串轉換為數字抛出的異常 stringindexoutofboundsexception 字元串索引超出範圍抛出的異常 illegalaccessexception 不允許通路某類異常 instantiationexception 當應用程式試圖使用class類中的newinstance()方法建立一個類的執行個體，而指定的類對象無法被執行個體化時，抛出該異常
6.自定義異常
使用java内置的異常類可以描述在程式設計時出現的大部分異常情況。除此之外，使用者還可以自定義異常。使用者自定義異常類，隻需繼承exception類即可。
在程式中使用自定義異常類，大體可分為以下幾個步驟。
（1）建立自定義異常類。
（2）在方法中通過throw關鍵字抛出異常對象。
（3）如果在目前抛出異常的方法中處理異常，可以使用try-catch語句捕獲并處理；否則在方法的聲明處通過throws關鍵字指明要抛出給方法調用者的異常，繼續進行下一步操作。
（4）在出現異常方法的調用者中捕獲并處理異常。
在上面的“使用throw抛出異常”例子已經提到了。