- 相關推薦
Java異常處理語句及解析
一、選擇題
1.java中用來拋出異常的關鍵字是 (C)
A、tryB、catchC、throw D、finally
2.關于異常，下列說法正確的是 (A)
A、異常是一種對象
B、一旦程序運行，異常將被創建
C、為了保證程序運行速度，要盡量避免異常控制
D、以上說法都丌對
3.（A）類是所有異常類的父類。
A、Throwable B、ErrorC、ExceptionD、AWTError
4.java語言中，下列哪一子句是異常處理的出口 (C)
A、try{?}子句 B、catch{?}子句
C、finally{?}子句 D、以上說法都丌對
5.下列程序的執行，說法錯誤的是 (C)
public class MultiCatch
{
public static void main(String args[])
{
try
{
int a=args.length;
int b=42/a;
int c[]={1};
c[42]=99;
System.out.println(“b=”+b);
}
catch(ArithmeticException e)
{
System.out.println(“除0異常：”+e);
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(“數組超越邊界異常：”+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)
{
System.out.println(“數組超越界限異常：”+e);
}
}
public static void main(String args[])
{
try
{
procedure();
int a=args.length;
int b=42/a;
System.out.println(“b=”+b);
}
catch(ArithmeticException e)
{
System.out.println(“除0異常：”+e);
}
}
}
A、程序只輸出第12行的異常信息
B、程序只輸出第26行的異常信息
C、程序將不輸出異常信息
D、程序將輸出第12行和第26行的異常信息
7.下面程序拋出了一個“異常”并捕捉它。請在橫線處填入適當內容完成程序。 class TrowsDemo
{
static void procedure() throws IllegalAccessExcepton
{
System.out.println(“inside procedure”);
throw_IllegalAccessException(“demo”);
}
public static void main(String args[])
{
try
{
procedure();
}
{
System.out.println(“捕獲：”+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________
{
System.out.println(greeting[i]);
}
____catch__(ArrayIndexOutOfBoundsException e)
{
System.out.println(“Re-setting Index Value”);
i=-1;}
finally
{
System.out.println(“This is always printed”);
}
i++;
}
}
三、判斷題
1. ( F ) 程序中拋出異常時(throw ?)，只能拋出自己定義的異常對象。
2. ( T ) 一個異常處理中 finally語句塊只能有一個或者可以沒有。
3.( T )異常類對象代表當前出現的一個具體異常。
4.( T )java語言中的所有異常類都是java.lang.Throwable的子類。
5.( F ) 如果異常發生時，沒有捕獲異常的代碼，程序會正常執行。
四、編程題
1．參考下面的程序，試修改程序，捕獲相關異常，使得程序能正常運行。[提示：用 錯誤數據測試，即可得到異常類名，運行時主方法參數輸入 abc 測試]
public class StringIndexOutOf
{
public static void main(String args[])
{
System.out.println("字符串索引越界異常");
String str=args[0];
System.out.println(“第四個字符為 ”+str.charAt(3));
int aa=Integer.parseInt(args[0]); System.out.println(“平方為 ”+aa*aa);
}
}
2． 從命令行得到5個整數，放入一整型數組，然后打印輸出，要求：如果輸入數據 丌為整數，要捕獲Integer.parseInt()產生的異常，顯示“請輸入整數”，捕獲輸入參 數丌足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）算數異常：java.lang.ArithmeticException
在算術運算中，0作為除數時，系統將產生該異常，示例：
public static void main(String[] args) {
} int x=10; int y=0; int m=x/y;
Exception in thread "main" java.lang.ArithmeticException: / by zero at exception.NotChecketException.main(NotChecketException.java:7)
（2）數組越界異常：java.lang.ArrayIndexOutOfBoundsException
在數組下標越界時，將產生該異常，示例：
public static void main(String[] args) {
} int arr[]={1,2,3}; System.out.println(arr[3]);
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3 at exception.NotChecketException.main(NotChecketException.java:6)
（3）數組存儲異常：java.lang.ArrayStoreException
在數組中存入與之聲明類型不符的類型，將產生該異常，示例：
public static void main(String[] args) {
} boolean[] b = {false,true,false}; int attr[] = {1,2,3}; System.arraycopy(attr, 0, b, 0, 1);
Exception in thread "main" java.lang.ArrayStoreException
at java.lang.System.arraycopy(Native Method) at exception.NotChecketException.main(NotChecketException.java:7)
（4）對象轉換異常：java.lang.ClassCastException
將對象A轉換成為對象B時，如果A既不是與B同一個類，也不是B的子類，將產生該異常，示例：
public static void main(String[] args) {
} Object obj = new Object(); int in[] = (int[]) obj;
Exception in thread "main" java.lang.ClassCastException:
java.lang.Object cannot be cast to [I
at exception.NotChecketException.main(NotChecketException.java:6)
（5）空指針異常：java.lang.NullPointerException
引用空對象的實例或方法時，將產生該異常。示例：
public static void main(String[] args) {
} String str = null; System.out.println(str.length());
Exception in thread "main" java.lang.NullPointerException
at exception.NotChecketException.main(NotChecketException.java:6)
2、try…catch語句捕獲異常
public class ExceptionDemo1 {
}
public static void main(String[] args) {} int i[] = { 1, 2, 3 }; try {System.out.println("i[0]=" + i[0]); System.out.println("i[3]=" + i[3]); } catch (ArrayIndexOutOfBoundsException e) { } System.out.println("i[1]=" + i[1]); System.out.println("出現異常" + e.getMessage());
以上面的程序運行結果可以發現，在程序中加入異常處理代碼后，當異常發生時，整個程序沒有因為異常的出現而中斷執行。
3、try…catch…finally語句捕獲異常
public class ExceptionDemo4 {
public static void main(String[] args) {int i[] = { 1, 2, 3 }; try {System.out.println("i[0]=" + i[0]); System.out.println("i[3]=" + i[3]); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("出現異常" + e.getMessage()); }finally{ System.out.println("......無論是否有異常，都會執行finally語句......");
} System.out.println("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("test.txt"); fr.read(); } catch (FileNotFoundException e) {// TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) {// TODO Auto-generated catch block e.printStackTrace(); }finally{ } try { fr.close(); } catch (IOException e) {} // TODO Auto-generated catch block e.printStackTrace();
使用多個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("不存在的文檔.txt"); fr.close(); } catch (IOException e) {} // TODO Auto-generated catch block e.printStackTrace();
6、錯誤的使用
throws
篇三：java中異常處理中return的用法
java中異常處理中return的用法 關于try、catch、finally語句塊中含有return語句的幾點說明：
1、第一種情況：try塊有return語句，catch塊沒有return，函數末尾也沒有return：
看代碼：
import java.util.*;
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 Demo.java
Demo.java:18: 缺少返回語句
}
^
1 錯誤
有人可能會說，我在try塊中不是有return語句嗎？為什么會提示缺少return語句呢？這是因為編譯器認為try塊中是又可能產生異常操作
的，也就是說在return語句之前如果出現異常的話，那么return語句根本沒有機會得到執行，所以編譯器會認為缺少return語句。
解決辦法:a、在catch塊中加入return語句，因為一旦出現異常，catch中的語句可以保證函數會有一個返回值
b、在finally塊中加入return語句，同樣只要系統不退出，finally語句塊會始終得到執行的
代碼：
import java.util.*;
public class Demo{
public static void main(String args[]){
int num = 10;
System.out.println(test(num));
}
public static int test(int b){
try{
b += 10;
return b;
}catch(Exception e){
}finally{ return 0;
}
}
}
c、在函數末尾加入return語句
代碼：
import java.util.*;
public class Demo{
public static void main(String args[]){
int num = 10;
System.out.println(test(num));
}
public static int test(int b){ try{
b += 10;
return b;
}catch(Exception e){
}finally{
}
return 0;
}
}
2、第二種情況，看代碼：
import java.util.*;
public class Demo{
public static void main(String args[]){
int num = 10;
System.out.println(test(num));
}
public static int test(int b){
try{
b += 10;
}
return 0;
}
}
結果：H:java Demo>javac Demo.java
Demo.java: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;
System.out.println(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;
System.out.println(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 Demo.java
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;
System.out.println(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;
System.out.println(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語句塊中剩
【Java異常處理語句及解析】相關文章：
Java 異常處理12-22
Java的異常處理及應用03-12
Java編程中異常處理的方法06-03
Java的異常機制分析及處理辦法02-05
Java編程中異常處理的最優法08-06
Java語言中的異常處理機制08-02
全面理解java中的異常處理機制精選08-11
關于Java語言的異常08-07
java運行異常的示例04-02