1. try-catch語句
在Java中，異常通過try-catch語句捕獲。其一般語法形式為：
|
1
2
3
4
5
6
7
8
|
try { // 可能會發生異常的程序代碼 } catch (Type1 id1){ // 捕獲并處置try拋出的異常類型Type1 } catch (Type2 id2){ //捕獲并處置try拋出的異常類型Type2 } |
關鍵詞try后的一對大括號將一塊可能發生異常的代碼包起來，稱為監控區域。Java方法在運行過程中出現異常，則創建異常對象。將異常拋出監控區域之 外，由Java運行時系統試圖尋找匹配的catch子句以捕獲異常。若有匹配的catch子句，則運行其異常處理代碼，try-catch語句結束。
匹配的原則是：如果拋出的異常對象屬于catch子句的異常類，或者屬于該異常類的子類，則認為生成的異常對象與catch塊捕獲的異常類型相匹配。
例1 捕捉throw語句拋出的“除數為0”異常。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class TestException { 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("程序正常結束。"); } } |
運行結果：
|
1
2
3
|
程序出現異常，變量b不能為0。程序正常結束。 |
例1 在try監控區域通過if語句進行判斷，當“除數為0”的錯誤條件成立時引發ArithmeticException異常，創建 ArithmeticException異常對象，并由throw語句將異常拋給Java運行時系統，由系統尋找匹配的異常處理器catch并運行相應異 常處理代碼，打印輸出“程序出現異常，變量b不能為0。”try-catch語句結束，繼續程序流程。
事實上，“除數為0”等ArithmeticException，是RuntimException的子類。而運行時異常將由運行時系統自動拋出，不需要使用throw語句。
例2 捕捉運行時系統自動拋出“除數為0”引發的ArithmeticException異常。
|
1
2
3
4
5
6
7
8
9
10
11
|
public static void main(String[] args) { int a = 6; int b = 0; try { System.out.println("a/b的值是：" + a / b); } catch (ArithmeticException e) { System.out.println("程序出現異常，變量b不能為0。"); } System.out.println("程序正常結束。"); } } |
運行結果：
|
1
2
3
|
程序出現異常，變量b不能為0。程序正常結束。 |
例2 中的語句：
|
1
|
System.out.println(“a/b的值是：” + a/b); |
在運行中出現“除數為0”錯誤，引發ArithmeticException異常。運行時系統創建異常對象并拋出監控區域，轉而匹配合適的異常處理器catch，并執行相應的異常處理代碼。
由于檢查運行時異常的代價遠大于捕捉異常所帶來的益處，運行時異常不可查。Java編譯器允許忽略運行時異常，一個方法可以既不捕捉，也不聲明拋出運行時異常。
例3 不捕捉、也不聲明拋出運行時異常。
|
1
2
3
4
5
6
7
8
|
public class TestException { public static void main(String[] args) { int a, b; a = 6; b = 0; // 除數b 的值為0 System.out.println(a / b); } } |
運行結果：
|
1
2
|
Exception in thread “main” java.lang.ArithmeticException: / by zeroat Test.TestException.main(TestException.java:8) |
例4 程序可能存在除數為0異常和數組下標越界異常。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class TestException { 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("程序正常結束。"); } } |
運行結果：
|
1
2
3
4
5
6
7
8
9
10
|
intArray[0] = 0intArray[0]模 -2的值: 0intArray[1] = 1intArray[1]模 -1的值: 0intArray[2] = 2<p>除數為0異常。</p><p>程序正常結束。</p> |
例4 程序可能會出現除數為0異常，還可能會出現數組下標越界異常。程序運行過程中ArithmeticException異常類型是先行匹配的，因此執行相匹配的catch語句：
|
1
2
3
|
catch (ArithmeticException e){ System.out.println("除數為0異常。"); } |
需要注意的是，一旦某個catch捕獲到匹配的異常類型，將進入異常處理代碼。一經處理結束，就意味著整個try-catch語句結束。其他的catch子句不再有匹配和捕獲異常類型的機會。
Java通過異常類描述異常類型，異常類的層次結構如圖1所示。對于有多個catch子句的異常程序而言，應該盡量將捕獲底層異常類的catch子 句放在前面，同時盡量將捕獲相對高層的異常類的catch子句放在后面。否則，捕獲底層異常類的catch子句將可能會被屏蔽。
RuntimeException異常類包括運行時各種常見的異常，ArithmeticException類和ArrayIndexOutOfBoundsException類都是它的子類。因此，RuntimeException異常類的catch子句應該放在 最后面，否則可能會屏蔽其后的特定異常處理或引起編譯錯誤。
2. try－catch-finally語句
try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現異常，都應當執行的內容。try-catch-finally語句的一般語法形式為：
|
1
2
3
4
5
6
7
8
9
|
try { // 可能會發生異常的程序代碼 } catch (Type1 id1) { // 捕獲并處理try拋出的異常類型Type1 } catch (Type2 id2) { // 捕獲并處理try拋出的異常類型Type2 } finally { // 無論是否發生異常，都將執行的語句塊 } |
例5 帶finally子句的異常處理程序。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class TestException { 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("--------------------------"); } } } } |
運行結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
Hello world !————————–Hello World !!————————–HELLO WORLD !!!————————–數組下標越界異常————————– |
在例5中，請特別注意try子句中語句塊的設計，如果設計為如下，將會出現死循環。如果設計為：
|
1
2
3
|
try { System.out.println (greetings[i]); i++; } |
小結：
try 塊：用于捕獲異常。其后可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。
catch 塊：用于處理try捕獲到的異常。
finally 塊：無論是否捕獲或處理異常，finally塊里的語句都會被執行。當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執行。在以下4種特殊情況下，finally塊不會被執行：
a.在finally語句塊中發生了異常。
b.在前面的代碼中用了System.exit()退出程序。
c.程序所在的線程死亡。
d.關閉CPU。
3. try-catch-finally 規則(異常處理語句的語法規則）：
a. 必須在 try 之后添加 catch 或 finally 塊。try 塊后可同時接 catch 和 finally 塊，但至少有一個塊。
b. 必須遵循塊順序：若代碼同時使用 catch 和 finally 塊，則必須將 catch 塊放在 try 塊之后。
c. catch 塊與相應的異常類的類型相關。
d. 一個 try 塊可能有多個 catch 塊。若如此，則執行第一個匹配塊。即Java虛擬機會把實際拋出的異常對象依次和各個catch代碼塊聲明的異常類型匹配，如果異常對象為某個異常類型或其子類的實例，就執行這個catch代碼塊，不會再執行其他的 catch代碼塊
e. 可嵌套 try-catch-finally 結構。
f. 在 try-catch-finally 結構中，可重新拋出異常。
g. 除了下列情況，總將執行 finally 做為結束：JVM 過早終止（調用 System.exit(int)）；在 finally 塊中拋出一個未處理的異常；計算機斷電、失火、或遭遇病毒攻擊。
4. try、catch、finally語句塊的執行順序:
a.當try沒有捕獲到異常時：try語句塊中的語句逐一被執行，程序將跳過catch語句塊，執行finally語句塊和其后的語句；
b.當try捕獲到異常，catch語句塊里沒有處理此異常的情況：當try語句塊里的某條語句出現異常時，而沒有處理此異常的catch語句塊時，此異常將會拋給JVM處理，finally語句塊里的語句還是會被執行，但finally語句塊后的語句不會被執行；
c.當try捕獲到異常，catch語句塊里有處理此異常的情況：在try語句塊中是按照順序來執行的，當執行到某一條語句出現異常時，程序將跳到catch語句塊，并與catch語句塊逐一匹配，找到與之對應的處理程序，其他的catch語句塊將不會被執行，而try語句塊中，出現異常之后的語句也不會被執行，catch語句塊執行完后，執行finally語句塊里的語句，最后執行finally語句塊后的語句；
圖示try、catch、finally語句塊的執行：
