一、選擇題
中用來丟擲異常的關鍵字是 (C)
A、tryB、catchC、throw D、finally
2.關於異常，下列說法正確的是 (A)
A、異常是一種物件
B、一旦程式執行，異常將被建立
C、為了保證程式執行速度，要儘量避免異常控制
D、以上說法都丌對
3.（A）類是所有異常類的父類。
A、Throwable B、ErrorC、ExceptionD、AWTError
語言中，下列哪一子句是異常處理的出口 (C)
A、try{?}子句 B、catch{?}子句
C、finally{?}子句 D、以上說法都丌對
5.下列程式的執行，說法錯誤的是 (C)
public class MultiCatch
{
public static void main(String args[])
{
try
{
int a=th;
int b=42/a;
int c[]={1};
c[42]=99;
tln(“b=”+b);
}
catch(ArithmeticException e)
{
tln(“除0異常：”+e);
}
catch(ArrayIndexOutOfBoundsException e) {
tln(“陣列超越邊界異常：”+e);
}
}
}
A、程式將輸出第15行的異常資訊
B、程式第10行出錯
C、程式將輸出“b=42”
D、程式將輸出第15和19行的異常資訊
6.下列程式的執行，說法正確的是 （D）
class ExMulti
{
static void procedure()
{
try
{
int c[]={1};
c[42]=99;
}
catch(ArrayIndexOutOfBoundsException e)
{
tln(“陣列超越界限異常：”+e);
}
}
public static void main(String args[])
{
try
{
procedure();
int a=th;
int b=42/a;
tln(“b=”+b);
}
catch(ArithmeticException e)
{
tln(“除0異常：”+e);
}
}
}
A、程式只輸出第12行的異常資訊
B、程式只輸出第26行的異常資訊
C、程式將不輸出異常資訊
D、程式將輸出第12行和第26行的異常資訊
7.下面程式丟擲了一個“異常”並捕捉它。請在橫線處填入適當內容完成程式。 class TrowsDemo
{
static void procedure() throws IllegalAccessExcepton
{
tln(“inside procedure”);
throw_IllegalAccessException(“demo”);
}
public static void main(String args[])
{
try
{
procedure();
}
{
tln(“捕獲：”+e);
}
}
8.對於catch子句的排列，下列哪種是正確的(B )
A、父類在先，子類在後
B、子類在先，父類在後
C、有繼承關係的異常不能在同一個try程式段內
D、先有子類，其他如何排列都無關
9.在異常處理中，如釋放資源、關閉檔案、關閉資料庫等由(C )來完成。
A、try子句 B、catch子句
C、finally子句D、throw子句
10.當方法遇到異常又不知如何處理時，下列哪種說法是正確的(C )
A、捕獲異常 B、丟擲異常
C、宣告異常 D、巢狀異常
11.哪個關鍵字可以丟擲異常？ （C）
A、transientB、 finallyC、 throw D、 static
12．一個異常將終止( A)
A、整個程式 B、叧終止丟擲異常的方法
C、產生異常的try塊 D、×上面的說法都丌對
二、填空題 Java異常處理 內部資料【機密】 交流QQ 250586262
1、catch子句都帶一個引數，該引數是某個異常的類及其變數名，catch用該引數去與 __出現異常_____物件的類進行匹配。
2、java虛擬機器能自動處理__執行異常_____異常。
3、變數屬性是描述變數的作用域，按作用域分類，變數有區域性變數、類變數、方法參 數和_______
4、捕獲異常要求在程式的方法中預先宣告，在呼叫方法時用try-catch-_finally_____語句捕 獲並處理。
5、java語言認為那些可預料和不可預料的出錯稱為____異常_____
6、按異常處理不同可以分為執行異常、捕獲異常、宣告異常和_丟擲異常_____幾種。
7、丟擲異常的程式程式碼可以是_自定義的異常_____或者是JDK中的某個類，還可以是JVM.
8、丟擲異常、生成異常物件都可以通過__throws_______語句實現。
9、捕獲異常的統一出口通過___finally______語句實現。
10、java語言的類庫中提供了一個___Throwable_______類，所有的異常都必須是它的例項
或它
子類的例項。
11、Throwable類有兩個子類：RunException___類和Exception類。
12、對程式語言而言，一般有編譯錯誤和__執行____錯誤兩類。
13、下面程式定義了一個字串陣列，並列印輸出，捕獲陣列超越界限異常。請在橫 線處填入適當的內容完成程式。
public class HelloWorld
{
int i=0;
String greetings[]={
“Hello world!”,
“No,I mean it!”,
“HELLO WORLD!!”
};
while(i<4)
{
____try________
{
tln(greeting[i]);
}
____catch__(ArrayIndexOutOfBoundsException e)
{
tln(“Re-setting Index Value”);
i=-1;}
finally
{
tln(“This is always printed”);
}
i++;
}
}
三、判斷題
1. ( F ) 程式中丟擲異常時(throw ?)，只能丟擲自己定義的異常物件。
2. ( T ) 一個異常處理中 finally語句塊只能有一個或者可以沒有。
3.( T )異常類物件代表當前出現的一個具體異常。
4.( T )java語言中的所有異常類都是wable的子類。
5.( F ) 如果異常發生時，沒有捕獲異常的程式碼，程式會正常執行。
四、程式設計題
1．參考下面的程式，試修改程式，捕獲相關異常，使得程式能正常執行。[提示：用 錯誤資料測試，即可得到異常類名，執行時主方法引數輸入 abc 測試]
public class StringIndexOutOf
{
public static void main(String args[])
{
tln("字串索引越界異常");
String str=args[0];
tln(“第四個字元為 ”+At(3));
int aa=eInt(args[0]); tln(“平方為 ”+aa*aa);
}
}
2． 從命令列得到5個整數，放入一整型陣列，然後列印輸出，要求：如果輸入資料 丌為整數，要捕獲eInt()產生的異常，顯示“請輸入整數”，捕獲輸入參 數丌足5個的異常(陣列越界)，顯示“請輸入至少5個整數”。
3．寫一個方法void sanjiao(int a,int b,int c)，判斷三個引數是否能構成一個三角形， 如果丌能則丟擲異常IllegalArgumentException，顯示異常資訊a,b,c+”丌能構成三角 形”，如果可以構成則顯示三角形三個邊長，在主方法中得到命令列輸入的三個整數， 呼叫此方法，並捕獲異常。
4．自定義類Sanj，其中有成員 x,y,z,作為三邊長，構造方法Sanj(a,b,c)分別給x,y,z 賦值,方法求面積getArea和顯示三角形資訊(三個邊長)showInfo，這2個方法中當三 條邊丌能構成一個三角形時要丟擲自定義異常NotSanjiaoException，否則顯示正確信 息。在另外一個類中的主方法中構造一個Sanj物件(三邊為命令列輸入的三個整數)， 顯示三角形資訊和麵積，要求捕獲異常。
篇二：Java中異常處理
第13章 異常課堂練習（2理論+2習題課+2上機）
【教學目標】
?
?
? 瞭解異常和異常處理的概貌（第13.2節）。 探究使用異常處理的優點（第13.3節）。 區別異常的型別： 致命的) 和 非致命的), 以及必檢和免檢異常（第13.4
節）。
?
?
?
?
?
?
?
?
? 在方法頭中宣告異常（第13.5.1節）。 在方法中丟擲異常（第13.5.2節）。 編寫塊處理異常（第13.5.3節）。 解釋異常是如何傳播的（第13.5.3節）。 在塊中使用子句（第13.6節）。 只為非預期錯誤使用異常（第13.7節）。 在塊中重新丟擲異常（第13.8節）。 建立鏈式異常（第13.9節）。 定義自定製的異常類（第13.10節）。
【教學重點】
?
?
?
? 瞭解異常的處理機制 異常的解決方法 Exception類的作用及其使用方法 必檢異常、免檢異常的特點
【基本知識點】
1、常見異常演示
（1）算數異常：hmeticException
在算術運算中，0作為除數時，系統將產生該異常，示例：
public static void main(String[] args) {
} int x=10; int y=0; int m=x/y;
Exception in thread "main" hmeticException: / by zero at (:7)
（2）陣列越界異常：yIndexOutOfBoundsException
在陣列下標越界時，將產生該異常，示例：
public static void main(String[] args) {
} int arr[]={1,2,3}; tln(arr[3]);
Exception in thread "main" yIndexOutOfBoundsException: 3 at (:6)
（3）陣列儲存異常：yStoreException
在陣列中存入與之宣告型別不符的型別，將產生該異常，示例：
public static void main(String[] args) {
} boolean[] b = {false,true,false}; int attr[] = {1,2,3}; ycopy(attr, 0, b, 0, 1);
Exception in thread "main" yStoreException
at ycopy(Native Method) at (:7)
（4）物件轉換異常：sCastException
將物件A轉換成為物件B時，如果A既不是與B同一個類，也不是B的子類，將產生該異常，示例：
public static void main(String[] args) {
} Object obj = new Object(); int in[] = (int[]) obj;
Exception in thread "main" sCastException:
ct cannot be cast to [I
at (:6)
（5）空指標異常：PointerException
引用空物件的例項或方法時，將產生該異常。示例：
public static void main(String[] args) {
} String str = null; tln(th());
Exception in thread "main" PointerException
at (:6)
2、try…catch語句捕獲異常
public class ExceptionDemo1 {
}
public static void main(String[] args) {} int i[] = { 1, 2, 3 }; try {tln("i[0]=" + i[0]); tln("i[3]=" + i[3]); } catch (ArrayIndexOutOfBoundsException e) { } tln("i[1]=" + i[1]); tln("出現異常" + essage());
以上面的程式執行結果可以發現，在程式中加入異常處理程式碼後，當異常發生時，整個程式沒有因為異常的出現而中斷執行。
3、try…catch…finally語句捕獲異常
public class ExceptionDemo4 {
public static void main(String[] args) {int i[] = { 1, 2, 3 }; try {tln("i[0]=" + i[0]); tln("i[3]=" + i[3]); } catch (ArrayIndexOutOfBoundsException e) { tln("出現異常" + essage()); }finally{ tln("......無論是否有異常，都會執行finally語句......");
} tln("i[1]=" + i[1]);
}
}
其中，不論try程式碼塊中發生了哪種異常，也不論try程式碼塊和catch程式碼塊是否可以正常執行，finally程式碼塊都保證會執行。即使前面的try…catch程式碼塊都無法捕獲這個異常，或者在catch程式碼塊中還有其他異常產生，在將新的異常傳遞給java執行時環境之前都會先執行finally程式碼塊。
4、多個catch程式碼塊
public class ExceptionDemo5 {
} public static void main(String[] args) { } FileReader fr = null; try {fr=new FileReader(""); (); } catch (FileNotFoundException e) {// TODO Auto-generated catch block tStackTrace(); } catch (IOException e) {// TODO Auto-generated catch block tStackTrace(); }finally{ } try { e(); } catch (IOException e) {} // TODO Auto-generated catch block tStackTrace();
使用多個catch語句塊的時候，請注意catch程式碼塊的排順序問題。Catch程式碼塊捕獲異常是按照順序的，如果前面已經有一個異常型別被捕獲了，但又同時滿足後面的異常型別時，就不會被捕獲了。
5、在呼叫方法出處理被丟擲的異常
public class Exception6 {
}
在上面的程式中，“不存在的文件”表示在同一個目錄下沒有該文件。當arrException()方法產生了異常，此方法並不作處理，而是交由呼叫arrException()方法的main方法處理。 public static void arrException() throws IOException{} public static void main(String[] args) { } try { arrException(); FileReader fr = new FileReader("不存在的文件"); e(); } catch (IOException e) {} // TODO Auto-generated catch block tStackTrace();
6、錯誤的使用
throws
篇三：java中異常處理中return的用法
java中異常處理中return的用法 關於try、catch、finally語句塊中含有return語句的幾點說明：
1、第一種情況：try塊有return語句，catch塊沒有return，函式末尾也沒有return：
看程式碼：
import .*;
public class Demo{
public static void main(String args[]){
int num = 10;
test(num);
}
public static int test(int b){
try{
b += 10;
return b;
}catch(Exception e){
}finally{
}
}
}
編譯結果：
H:java Demo>javac
: 缺少返回語句
}
^
1 錯誤
有人可能會說，我在try塊中不是有return語句嗎？為什麼會提示缺少return語句呢？這是因為編譯器認為try塊中是又可能產生異常操作
的，也就是說在return語句之前如果出現異常的.話，那麼return語句根本沒有機會得到執行，所以編譯器會認為缺少return語句。
解決辦法:a、在catch塊中加入return語句，因為一旦出現異常，catch中的語句可以保證函式會有一個返回值
b、在finally塊中加入return語句，同樣只要系統不退出，finally語句塊會始終得到執行的
程式碼：
import .*;
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){
try{
b += 10;
return b;
}catch(Exception e){
}finally{ return 0;
}
}
}
c、在函式末尾加入return語句
程式碼：
import .*;
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){ try{
b += 10;
return b;
}catch(Exception e){
}finally{
}
return 0;
}
}
2、第二種情況，看程式碼：
import .*;
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){
try{
b += 10;
}
return 0;
}
}
結果：H:java Demo>javac
:8: "try" 不帶有 "catch" 或 "finally"
try{
^
1 錯誤
說明：也就是說，如果有try語句的話，可以有catch語句，沒有finally語句，但是如果沒有catch語句的話，那麼一定要有finally語句
。並且如果出現catch語句的話，catch語句可以出現多次，而finally語句只能出現一次。
程式碼：
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){ try{
b += 10;
}catch(RuntimeException e){
}catch(Exception e2){
}finally{
}
return 0;
}
}
3、第三種情況：
a、try塊中有return語句，那麼是先執行return語句，還是先執行finally語句。大家通常會有一個錯誤的認識，可能有的老師都會講錯
，認為是先執行finally語句，再執行return語句，但是這是錯誤的，事實上是先執行return語句，再執行finally語句，然後將結果返回，也可以說return語句執行了兩次，一次在finally之前，一次在finally之後，但是返回的確是第一次執行的值
，如果有不信的，請繼續看程式碼，此段程式碼可以證明我的觀點：
程式碼：
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){
try{
b += 10;
return b;
}catch(RuntimeException e){
}catch(Exception e2){ }finally{
b += 10;
}
return 0;
}
}
結果：
H:java Demo>javac
H:java Demo>java Demo 20
說明：此處需要引入緩衝的概念，有對緩衝不太瞭解的也沒關係，程式執行結果是20足以證明我的觀點，程式執行流程是進入try語句塊
執行return語句，但是程式有finally語句塊，所有先將return返回的值緩衝起來，然後程式跳轉到finally語句塊執行，我在finally語
句塊中修改了變數b的值，但是程式返回的依然是20，並不是30，說明finally語句塊執行完畢後，程式直接將之前緩衝的值返回了。所以
這就是真實的執行流程。
b、try塊中有return，finally語句塊中也有return，此時的情況是什麼樣呢？ 看程式碼：
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){
try{
b += 10;
return b;
}catch(RuntimeException e){
}catch(Exception e2){
}finally{
b += 10;
return b;
}
} }
結果是：
H:java Demo>java Demo
30
說明：為什麼此時結果是30了呢，大家都知道return語句的作用是結束程式體，所以此段程式碼依然是先執行try塊中的return語句，並將20
快取起來，接著跳轉到finally語句塊執行，但是由於finally語句塊中有return語句，所以程式在此處結束，並不返回到try塊中返回結
果，而是直接將finally塊中新修改的值即30，返回。
c、try塊中有return語句，catch塊中也有return語句，這時候是最簡單的一種情況：
看程式碼：
public class Demo{
public static void main(String args[]){
int num = 10;
tln(test(num));
}
public static int test(int b){
try{
int a = b/0;
return b;
}catch(Exception e2){
b += 10;
return b;
}
}
}
結果：
H:java Demo>java Demo
20
說明：我在try塊中觸發了一個異常，程式跳入catch語句塊，try語句塊中剩
