Java try和catch的使用
盡管由Java運行時系統(tǒng)提供的默認異常處理程序對于調試是很有用的，但通常你希望自己處理異常。這樣做有兩個好處。第一，它允許你修正錯誤。第二，它防止程序自動終止。大多數用戶對于在程序終止運行和在無論何時錯誤發(fā)生都會打印堆棧軌跡感到很煩惱（至少可以這么說）。幸運的是，這很容易避免。
為防止和處理一個運行時錯誤，只需要把你所要監(jiān)控的代碼放進一個try塊就可以了。緊跟著try塊的，包括一個說明你希望捕獲的錯誤類型的catch子句。完成這個任務很簡單，下面的程序包含一個處理因為被零除而產生的ArithmeticException 異常的try塊和一個catch子句。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Exc2 { public static void main(String args[]) { int d, a; try { // monitor a block of code. d = 0; a = 42 / d; System.out.println("This will not be printed."); } catch (ArithmeticException e) { // catch divide-by-zero error System.out.println("Division by zero."); } System.out.println("After catch statement."); }} |
該程序輸出如下：
|
1
2
|
Division by zero.After catch statement. |
注意在try塊中的對println( )的調用是永遠不會執(zhí)行的。一旦異常被引發(fā)，程序控制由try塊轉到catch塊。執(zhí)行永遠不會從catch塊“返回”到try塊。因此，“This will not be printed。”
將不會被顯示。一旦執(zhí)行了catch語句，程序控制從整個try/catch機制的下面一行繼續(xù)。
一個try和它的catch語句形成了一個單元。catch子句的范圍限制于try語句前面所定義的語句。一個catch語句不能捕獲另一個try聲明所引發(fā)的異常（除非是嵌套的try語句情況）。
被try保護的語句聲明必須在一個大括號之內（也就是說，它們必須在一個塊中）。你不能單獨使用try。
構造catch子句的目的是解決異常情況并且像錯誤沒有發(fā)生一樣繼續(xù)運行。例如，下面的程序中，每一個for循環(huán)的反復得到兩個隨機整數。這兩個整數分別被對方除，結果用來除12345。最后的結果存在a中。如果一個除法操作導致被零除錯誤，它將被捕獲，a的值設為零，程序繼續(xù)運行。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
// Handle an exception and move on.import java.util.Random;class HandleError { public static void main(String args[]) { int a=0, b=0, c=0; Random r = new Random(); for(int i=0; i<32000; i++) { try { b = r.nextInt(); c = r.nextInt(); a = 12345 / (b/c); } catch (ArithmeticException e) { System.out.println("Division by zero."); a = 0; // set a to zero and continue } System.out.println("a: " + a); } }} |
顯示一個異常的描述
Throwable重載toString( )方法（由Object定義），所以它返回一個包含異常描述的字符串。你可以通過在println( )中傳給異常一個參數來顯示該異常的描述。例如，前面程序的catch塊可以被重寫成
|
1
2
3
4
|
catch (ArithmeticException e) { System.out.println("Exception: " + e); a = 0; // set a to zero and continue} |
當這個版本代替原程序中的版本，程序在標準javaJDK解釋器下運行，每一個被零除錯誤顯示下面的消息：
|
1
|
Exception: java.lang.ArithmeticException: / by zero |
盡管在上下文中沒有特殊的值，顯示一個異常描述的能力在其他情況下是很有價值的——特別是當你對異常進行實驗和調試時。
Java 多重catch語句的使用
某些情況，由單個代碼段可能引起多個異常。處理這種情況，你可以定義兩個或更多的catch子句，每個子句捕獲一種類型的異常。當異常被引發(fā)時，每一個catch子句被依次檢查，第一個匹配異常類型的子句執(zhí)行。當一個catch語句執(zhí)行以后，其他的子句被旁路，執(zhí)行從try/catch塊以后的代碼開始繼續(xù)。下面的例子設計了兩種不同的異常類型：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
// Demonstrate multiple catch statements.class MultiCatch { public static void main(String args[]) { try { int a = args.length; System.out.println("a = " + a); int b = 42 / a; int c[] = { 1 }; c[42] = 99; } catch(ArithmeticException e) { System.out.println("Divide by 0: " + e); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index oob: " + e); } System.out.println("After try/catch blocks."); }} |
該程序在沒有命令行參數的起始條件下運行導致被零除異常，因為a為0。如果你提供一個命令行參數，它將幸免于難，把a設成大于零的數值。但是它將導致ArrayIndexOutOf BoundsException異常，因為整型數組c的長度為1，而程序試圖給c[42]賦值。
下面是運行在兩種不同情況下程序的輸出：
|
1
2
3
4
5
6
|
C:\>java MultiCatcha = 0Divide by 0: java.lang.ArithmeticException: / by zero After try/catch blocks.C:\>java MultiCatch TestArga = 1Array index oob: java.lang.ArrayIndexOutOfBoundsException After try/catch blocks. |
當你用多catch語句時，記住異常子類必須在它們任何父類之前使用是很重要的。這是因為運用父類的catch語句將捕獲該類型及其所有子類類型的異常。這樣，如果子類在父類后面，子類將永遠不會到達。而且，Java中不能到達的代碼是一個錯誤。例如，考慮下面的程序：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/* This program contains an error.A subclass must come before its superclass in a series of catch statements. If not,unreachable code will be created and acompile-time error will result.*/class SuperSubCatch { public static void main(String args[]) { try { int a = 0; int b = 42 / a; } catch(Exception e) { System.out.println("Generic Exception catch."); } /* This catch is never reached because ArithmeticException is a subclass of Exception. */ catch(ArithmeticException e) { // ERROR - unreachable System.out.println("This is never reached."); } }} |
如果你試著編譯該程序，你會收到一個錯誤消息，該錯誤消息說明第二個catch語句不會到達，因為該異常已經被捕獲。因為ArithmeticException 是Exception的子類，第一個catch語句將處理所有的面向Exception的錯誤，包括ArithmeticException。這意味著第二個catch語句永遠不會執(zhí)行。為修改程序，顛倒兩個catch語句的次序。
