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异常处理语句及解析】相关文章：