Java异常处理的基础知识.docx
《Java异常处理的基础知识.docx》由会员分享,可在线阅读,更多相关《Java异常处理的基础知识.docx(14页珍藏版)》请在冰豆网上搜索。
Java异常处理的基础知识
异常处理
教学提示:
本章我们将讨论Java的异常处理机制,并学习如何合理应用异常处理机制,从而使我们编写的Java程序具有稳定性和可靠性。
当异常情况发生时,会创建一个代表该异常的对象并在产生异常的方法中引发该对象,这个异常最终会被捕获并进行相应的处理。
教学目标:
了解传统错误处理和面向对象中的异常处理的差别;理解异常处理的优越性;掌握如何在程序中抛出、捕获和处理异常;了解自定义异常的方法。
9.1Java异常处理的基础知识
9.1.1错误与异常
在程序运行时经常会出现一些非正常的现象,如死循环、非正常退出等,称为运行错误。
根据错误性质将运行错误分为两类:
错误和异常。
1.致命性的错误
如程序进入了死循环,或递归无法结束,或内存溢出,这类现象称为错误。
错误只能在编程阶段解决,运行时程序本身无法解决,只能依靠其他程序干预,否则会一直处于非正常状态。
2.非致命性的异常
如运算时除数为0,或操作数超出数据范围,或打开一个文件时,发现文件并不存在,或欲装入的类文件丢失,或网络连接中断等,这类现象称为异常。
在源程序中加入异常处理代码,当程序运行中出现异常时,由异常处理代码调整程序运行方向,使程序仍可继续运行直至正常处理。
9.1.2异常处理机制
Java提供了异常处理机制,它是通过面向对象的方法来处理异常的。
1.抛出异常
当程序发生异常时,产生一个异常事件,生成一个异常对象,并把它提交给运行系统,再由运行系统寻找相应的代码来处理异常。
这个过程称为抛出(throw)一个异常。
一个异常对象可以由Java虚拟机生成,也可以由运行的方法生成。
异常对象中包含了异常事件类型、程序运行状态等必要的信息。
2.捕获异常
异常抛出后,运行时系统从生成对象的代码开始,沿方法的调用栈逐层回溯查找,直到包含相应处理的方法,并把异常对象交给该方法为止,这个过程称为捕获(catch)一个异常。
简单地说,发现异常的代码可以“抛出”一个异常,运行系统“捕获”该异常,交由程序员编写的相应代码进行异常处理。
3.异常处理的类层次
Java通过错误类(Error)和异常类(Exception)来处理错误和异常,而它们都是Throwable类的子类,分别用来处理两组异常。
它们的层次结构如图9-1所示。
图9-1异常类层次结构
注意:
Throwable类是直接由Object类继承而来的一个类,可见Java对异常控制是非常重视的。
4.程序对错误与异常的三种处理方式:
⑴程序不能处理的错误
Error类为错误类,如内存溢出、栈溢出等。
这类错误一般由系统进行处理,程序本身无需捕获和处理。
例如,运行没有main方法的类将产生NoClassDefFoundError错误。
⑵程序应避免而不捕获的异常
对于运行时异常类(RuntimeException),如数组越界等,在程序设计正常时不会发生,在编程时使用数组长度a.length来控制数组的上界即可避免异常发生,而无须使用try-catch-finally语句。
因此,这类异常应通过程序调试尽量避免而不是去捕获它。
⑶必须捕获的异常
有些异常在编写程序时是无法预料了,如文件没找到异常、网络通信失败异常等。
因此,为了保证程序的健壮性,Java要求必须对可能出现这些异常的代码使用try-catch-finally语句,否则编译无法通过。
【例9-1】文件没有找到异常类。
设计思路:
本例访问文件autoexec.bat。
在程序中使用了FileInputStream类,在访问文件时会产生文件不存在的异常对象(FileNotFoundException),所以必须捕获的这个异常,否则编译就会出错。
代码:
importjava.io.*;
publicclassTry3
{
publicstaticvoidmain(Stringargs[])
{
FileInputStreamfis=newFileInputStream("autoexec.bat");
System.out.println("Icannotfoundthisfile!
");
}
}
程序运行效果如下:
图9-1
5.常见的公用异常类
下面介绍常见的异常类,它们都是RuntimeException的子类。
⑴算术异常ArithmeticException
如果除数为除0,或用0取模会产生ArithmeticException,其它算术操作不会产生异常。
⑵空指针异常NullPointerException
当程序试图访问一个空对象中的变量或方法,或一个空数组中的元素时则会引发NullPointerException异常。
例如,
inta[]=null;
a[0]=0;//访问长度为0的数组,产生NullPointerException
Stringstr=null;
System.out.println(str.length());//访问空字符串的方法,产生NullPointerException
⑶类型强制转换异常ClassCastException
进行类型强制转换时,对于不能进行的转换操作产生ClassCastException异常。
例如,
Objectobj=newObject();
Stringstr=(String)obj;
上述语句试图把Object对象强制转换成String对象str,而obj既不是String的实例,也不是String子类的实例,系统不能转换时产生ClassCastException异常。
⑷数组负下标异常NegativeArraySizeException
如果一个数组的长度是负数,则会引发NegativeArraySizeException异常。
例如,
inta[]=newint[-1];//产生NegativeArraySizeException异常
⑸数组下标越界异常ArrayIndexOutOfBoundsException
试图访问数组中的一个非法元素时,引发ArrayIndexOutOfBoundsExceptiony异常。
例如,
inta[]=newint[1];
a[0]=0;
a[1]=1;//数组下标越界异常
9.2异常类的产生、捕获和处理
异常处理的理论似乎十分繁琐,实际使用时却并不复杂。
下面我们先通过一个例子来看一下异常产生到捕获并处理的过程。
9.2.1异常的产生
【例9-2】产生数组下标越界异常和除数为0异常。
设计思路:
打印一个数组的所有值。
程序编译时没有问题,但运行时正常输出了循环的前4句,但在试图输出A[4]时,Java抛出了一个数组越界异常类(java.lang.ArrayIndexOutOfBoundsException),以及异常发生所在的方法(Try1.main),同时终止程序运行;
publicclassTry1
{
publicstaticvoidmain(Stringargs[])
{
inti=0;
inta[]={5,6,7,8};
for(i=0;i<5;i++)
System.out.println("a["+i+"]="+a[i]);
}
}
程序运行效果如下:
图9-2
9.2.2使用try-catch-finally语句捕获和处理异常
一般来说,系统捕获抛出的异常对象并输出相应的信息,同时终止程序运行,导致其后程序无法运行。
这其实并不是人们所期望的,因此就需要能让程序来接收和处理异常对象,从而不会影响其他语句的执行,这就是捕获异常的意义所在。
在Java的异常处理机制中,提供了try-catch-finally语句来捕获和处理一个或多个异常,语法格式如下:
try
{
<语句1>
}
catch(ExceptionType1e)
{
<语句2>
}
finally
{
<语句3>
}
其中,<语句1>是可能产生异常的代码;<语句2>是捕获某种异常对象时进行处理的代码,ExceptionType1代表某种异常类,e为相应的对象;<语句3>是其后必须执行的代码,无论是否捕获到异常。
catch语句可以有一个或多个,但至少要有一个catch语句,finally语句可以省略。
try-catch-finally语句的作用是,当try语句中的代码产生异常时,根据异常的不同,由不同catch语句中的代码对异常进行捕获并处理;如果没有异常,则catch语句不执行;而无论是否捕获到异常都必须执行finally中的代码。
【例9-3】异常捕获和处理。
设计思路:
本例使用try-catch-finally语句对例9-2中产生的异常进行捕获和处理。
publicclassTry2{
publicstaticvoidmain(Stringargs[]){
inti=0;
inta[]={5,6,7,8};
for(i=0;i<5;i++){
try{
System.out.println("a["+i+"]="+a[i]);
}
catch(ArrayIndexOutOfBoundsExceptione){
System.out.println("数组下标越界异常!
");
}
finally{
System.out.println("fianllyi="+i);
}
}
}
}
程序运行效果如下:
图9-3
通过这个例子我们再来深入讨论try-catch-finally语句,以及使用时要注意的问题。
⑴try语句
try语句大括号{}中的这段代码可能会抛出一个或多个异常。
也就是说,当某段代码在运行时可能产生异常的话,需要使用try语句来试图捕获这个异常
⑵catch语句
catch语句的参数类似于方法的声明,包括一个异常类型和一个异常对象。
catch语句可以有多个,分别处理不同类的异常。
Java运行时系统从上向下分别对每个catch语句处理的异常类型进行检测,直到找到与类型相匹配的catch语句为止。
如果程序产生的异常和所有catch的处理的异常都不匹配,则这个异常将由Java虚拟机捕获并处理,此时与不使用try-catch-finally语句是一样的,这显然也不是我们所期望的结果。
因此一般在使用catch语句时,最后一个将捕获Exception这个所有异常的超类,从而保证异常由对象自身来捕获和处理。
⑶finally语句
try所限定的代码中,当抛出一个异常时,其后的代码不会被执行。
通过finally语句可以指定一块代码,无论try所指定的程序块中抛出异常,也无论catch语句的异常类型是否与所抛出的异常的类型一致,finally所指定的代码都要被执行,它提供了统一的出口。
该语句是可以省略的。
9.3抛出异常
如前所述,在捕获一个异常前,必须有一段代码生成一个异常对象并把它抛出。
抛出异常的既可以是Java运行时系统,如例9-2;也可以是程序员自己编写的代码,即在try语句中的代码本身不会有系统产生异常,而是由程序员故意抛出异常。
9.3.1使用throw语句抛出异常
使用throw语句抛出异常格式如下:
throw<异常对象>
其中,throw是关键字,<异常对象>是创建的异常类对象。
【例9-4】抛出异常。
设计思路:
本例为求1-20的阶乘。
在该例中使用主动抛出异常、再捕获并处理异常的方式解决数据溢出的问题。
在每次乘法前先判断,如果结果会溢出,则由throw语句抛出一个异常,再由catch语句对捕获的异常进行处理。
publicclassTry5{
publicvoidrun(bytek){
bytey=1,i=1;
System.out.print(k+"!
=");//不换行输出
for(i=1;i<=k;i++)
{
try
{
if(y>Byte.MAX_VALUE/i)//Integer类的常量,表示最大值
thrownewException("overflow");//溢出时抛出异常
else
y=(byte)(y*i);
}
catch(Exceptione)
{
System.out.println("exception:
"+e.getMessage());
e.printStackTrace();//显示异常信息
System.exit(0);
}
}
System.out.println(y);
}
publicstaticvoidmain(Stringargs[])
{
Try5a=newTry5();
for(bytei=1;i<10;i++)
a.run(i);
}
}
程序运行效果如下:
图9-4
9.3.2抛出异常的方法与调用方法处理异常
⑴抛出异常的方法
在方法声明中,添加throws子句表示该方法将抛出异常。
带有throws子句的方法的声明格式如下:
[<修饰符>]<返回值类型><方法名>([<参数列表>])[throws<异常类>]
其中,throws是关键字,<异常类>是方法要抛出的异常类,可以声明多个异常类,用逗号隔开。
注意:
将throws子句与throws在语法和使用上要加以区别。
⑵由调用方法处理异常
由一个方法抛出异常后,系统将异常向上传播,由调用它的方法来处理这些异常。
【例9-5】抛出异常的方法与调用方法处理异常
设计思路:
本例在计算阶乘的calc方法中抛出数据溢出的异常。
程序运行时,在Calc方法中生成的异常通过调用栈传递给run方法,由run方法进行处理。
publicclassTry6{
publicvoidcalc(bytek)throwsException{//抛出异常
bytey=1,i=1;
System.out.print(k+"!
=");
for(i=1;i<=k;i++){
try{
if(y>Byte.MAX_VALUE/i)//Integer类的常量,表示最大值
thrownewException("overflow");//溢出时抛出异常
else
y=(byte)(y*i);
}
catch(Exceptione){
System.out.println("exception:
"+e.getMessage());
e.printStackTrace();
System.exit(0);
}
}
System.out.println(y);
}
publicvoidrun(bytek){//捕获并处理异常
try{
calc(k);
}
catch(Exceptione){
System.out.println("exception:
"+e.getMessage());
e.printStackTrace();
System.exit(0);
}
}
publicstaticvoidmain(Stringargs[]){
Try6a=newTry6();
for(bytei=1;i<10;i++)
a.run(i);
}
}程序运行效果如下:
图9-5
同throw一样,如果某个方法声明抛出异常,则调用它的方法必须捕获及处理异常,否则会出现异常错误。
9.3.3由方法抛出异常交系统处理
对于程序中需要处理的异常,一般编写try-catch-finally语句捕获并处理;而对于程序中无法处理必须由系统处理的异常,可以使用throw语句在方法中抛出异常交系统处理。
例如,对于文件流操作,将必须捕获的系统定义的异常交由系统系统处理。
publicclassDemo1//异常用法举例
{
staticinta,b,c;
publicstaticvoidmain(Stringargs[])
{
try
{a=100;
b=Integer.parseInt(args[0]);
if(b==13)
throw(newArithmeticException());//方法中抛出异常
c=a/b;
System.out.println("a/b="+c);
}
catch(ArrayIndexOutOfBoundsExceptione)
{System.out.println("没有命令行第一个参数");}
catch(ArithmeticExceptione)
{System.out.println("算数运算错误");}
}
}
9.4自定义异常类
虽然Java已经预定义了很多异常类,但有的情况下,程序员不仅需要自己抛出异常,还要创建自己的异常类。
这时可以通过创建Exception的子类来定义自己的异常类。
下面给出一些原则,提示读者何时需要自定义异常类。
满足下列任何一种或多种情况就应该考虑自己定义异常类。
1.Java异常类体系中不包含所需要的异常类型。
2.用户需要将自己所提供类的异常与其他人提供的异常进行区分。
3.类中将多次抛出这种类型的异常。
4.如果使用其它程序包中定义的异常类,将影响程序包的独立性与自包含性。
【例9-6】自定义异常类。
设计思路:
此例中定义了一个异常类MyException,该类是java.lang.Exception类的子类,只包含了两个简单的构造方法。
UsingMyexception类包含了两个方法f()和g(),这两个方法中分别声明并抛出了MyException类型的异常。
在TestMyExceptionlei类的main()方法中,访问了UsingMyException类的f()和g(),并用try-catch语句实现了异常处理。
在捕获了f()和g()抛出的异常后,将在相应的Catch语句块中输出异常的信息,并输出异常发生位置的堆栈跟踪轨迹。
代码:
classMyExceptionextendsException//自定义异常类
{
MyException(){}
MyException(Stringmsg)
{super(msg);}
}
classUsingMyException//抛出异常类
{
Voidf()throwsMyException
{
System.out.println("ThrowsMyExceptionfromf()");
thrownewMyException();
}
Voidg()throwsMyException
{
System.out.println("ThrowsMyExceptionfromg()");
thrownewMyException("originateding()");
}
}
publicclassTestMyException//捕获并处理异常
{
publicstaticvoidmain(Stringargs[]){
UsingMyExceptionm=newUsingMyException();//创建自定义异常类对象
try{
m.f();
}
catch(MyExceptione){
e.printStackTrace();
}
try{
m.g();
}
catch(MyExceptione){
e.printStackTrace();
}
}
}
程序运行效果如下:
图9-6