§ 2.8 异常处理
? 本节主要内容
– 异常的概念
– 异常的分类
– 声明异常
– 抛出异常
– 捕获并处理异常
– 自定义异常类
2.8.1异常的概念
? 异常是一种因程序中的错误而导致中断正常指令流的事件。
? 没有处理错误的程序,
read-file {
openTheFile;
determine its size;
allocate that much memory;
closeTheFile;
}
2.8.1异常的概念
以常规方法处理错误
openFiles;
if (theFilesOpen) {
determine the lenth of the file;
if (gotTheFileLength){
allocate that much memory;
if (gotEnoughMemory) {
read the file into memory;
if (readFailed)
errorCode=-1;
}else
errorCode=-2;
}else
errorCode=-3 ;
}else
errorCode=-4;
2.8.1异常的概念
? 观察前面的程序你会发现大部分精力花在出错处理上
了,
? 只把能够想到的错误考虑到,对以外的情况无法处理
? 程序可读性差
? 出错返回信息量太少
2.8.1异常的概念
? 用异常的形式处理错误
read-File;
{ try {
openTheFile;
determine its size;
allocate that much memory;
closeTheFile;
}catch(fileopenFailed){
dosomething;
} catch(sizeDetermineFailed) {
dosomething;
}catch(memoryAllocateFailed){
dosomething;
}catch(readFailed){
dosomething;
} catch(fileCloseFailed) {
dosomething;
}
2.8.1异常的概念
? 和传统的方法比较异常的优点,
1.把错误代码从常规代码中分离出来
2.把错误传播给调用堆栈
3.按错误类型和错误差别分组
4.系统提供了对于一些无法预测的错误的捕获和处理
5.克服了传统方法的错误信息有限的问题
method1
method2
method3
method4 产生异常
传
递 处理异常
2.8.1异常的概念
class ExcepTest
{ public static void main(String args[])
{ int b=0; int a;
try {
a=4/b;
} catch(ArithmeticException e）
{ System.out.println(“divided by 0”);}
}
}
2.8.2异常的分类
? 异常是一个对象,它继承自 Throwable类,
? Error:由 Java虚拟机生成并抛出,Java程序不做处理,
? Runtime Exception(被 0除等系统错误,数组下标超范围 ):
由系统检测,用户的 Java 程序可不做处理,系统将它们
交给缺省的异常处理程序,
? Exception(程序中的问题,可预知的 ),Java编译器要求
Java程序必须捕获或声明所有的非运行时异常
? throw:用户自己产生异常
2.8.2异常的分类
?,
Throwable
Error
Exception
RuntimeException
缺省的异常
处理程序
由用户捕获或
声明并处理
不做处理
用户自己产生的异常
要处理
2.8.3捕获并处理异常
? 捕获并处理异常
try {
//接受监视的程序块,在此区域内发生
//的异常,由 catch中指定的程序处理 ;
}catch(要处理的异常种类和标识符 ) {
//处理异常 ;
}catch(要处理的异常种类和标识符 ) {
//处理异常 ;
}
2.8.3捕获并处理异常
? 常见的异常
– ArithmeticException
– ArrayIndexOutOfBandsException
– ArrayStoreException
– IOException
– FileNotFoundException
– NullPointerException
– MalformedURLException
– NumberFormatException
– OutOfMemoryException
如果在使用能够
产生异常的方法
而没有捕获和处
理，将不能通过
编译
2.8.3捕获并处理异常
? 示例 2.8.2 下面这段代码，演示了算术异常、字
符串越界、数组越界三种异常，请观察输出信
息。（见书 138页）
2.8.3捕获并处理异常
? 一定会执行的程序块 ---finally
异常处理的统一出口
try {
//常规的代码 ;
}
catch()
{ //处理异常 }
finally {
//不论发生什么异常 (或者不发生任何异常 ),都要执行的部分 ;
}
2.8.3捕获并处理异常
finally在文件处理时非常有用
try {
对文件进行处理的程序 ;
}catch(IOException e) {
//对文件异常进行处理 ;
}finally {
不论是否发生异常,都关闭文件 ;
}
2.8.4声明异常
? 一个方法不处理它产生的异常,而是沿着调用层次向上
传递,由调用它的方法来处理这些异常,叫声明异常,
? 声明异常的方法
? 在产生异常的方法名后面加上要抛出 (throws)的异常
的列表
? void compute(int x)throws ArithmeticException {… }
? returnType methodName([parameterlist]) throws
exceptionList
2.8.4声明异常
例,若因
某种原
因不想
在计算
方法中
处理异
常
public method1()
{ int x;
try { x=System.in.read();
compute(x);}
catch(IOException ioe)
{ System.out.println(“read error”); }
catch(ArithmeticException e)
{ System.out.println(“devided by 0”); }
}
public int compute(int x) throws
ArithmeticException
{ return z=100/x;}
2.8.4声明异常
method1
computer
异常 抛出
处理
2.8.4声明异常
例,说出程序执行结果
public class exception1
{ void Proc(int sel) throws
ArithmeticException,
ArrayIndexOutOfBoundsException
{ System.out.println(“In Situation" + sel );
if (sel==0) {
System.out.println("no Exception caught");
return;
}else if(sel==1) {int iArray[]=new int[4];
iArray[10]=3;
}
}
2.8.4声明异常
public static void main(String args[])
{ try { Proc(0);
Proc(1);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Catch"+e);
}
}
2.8.5抛出异常
? 抛弃异常, 不是出错产生,而是人为地抛出
? throw ThrowableObject;
? throw new ArithmeticException();
? 例,编写程序人为抛出 (JavaThrow.java)
ArithmeticException,
ArrayIndexOutOfBoundsException
StringIndexOutOfBoundsException
A method Exception Another method
throw caught
class JavaThrow
{ public static void main(String args[])
{ try{ throw new ArithmeticException();}
catch(ArithmeticException ae)
{ System.out.println(ae); }
try{ throw new
ArrayIndexOutOfBoundsException();}
catch(ArrayIndexOutOfBoundsException ai)
{ System.out.println(ai); }
try { throw new
StringIndexOutOfBoundsException();}
catch(StringIndexOutOfBoundsException si){
{ System.out.println(si); } }
2.8.6自定义异常类
? 自定义异常不是由 Java系统监测到的异常 (下标
越界,被 0-除等 ),而是由用户自己定义的异常,
? 用户定义的异常同样要用 try--catch捕获,但必须
由用户自己抛出 throw new MyException,
? 异常是一个类,用户定义的异常必须继承自
Throwable或 Exception类,建议用 Exception类,
2.8.6自定义异常类
? 形如,
? class MyException extends Exception
? {….};
? 例 1,计算两个数之和,当任意一个数超出范围时,抛出自己的
异常
public class NumberRangeException extends
Exception
{ public NumberRangeException(String msg)
{ super(msg); }
}
2.8.6自定义异常类
import java.util.*;
import java.io.*;
public class SelfException{
public SelfException()
{ }
public int selfExceptionTest(int int1,int int2) throws
NumberRangeException
{
if(((int1<10)||(int1>20))||((int2<10)||(int2>20))){
throw new NumberRangeException(“数值超出了指定的范围！ ");
}else{
int1=int1+int2;
}
return int1;
}
2.8.6自定义异常类
public static void main(String[] args){
SelfException self= new SelfException();
try{
int calc = self.selfExceptionTest(18,19);
String answerStr= String.valueOf(calc);
System.out.println("Answer,"+answerStr);
calc = self.selfExceptionTest(8,9);
System.out.println("Answer,"+answerStr);
answerStr= String.valueOf(calc);
}catch(NumberRangeException e){
System.out.println("Catch," +e);
}
}
}
小结
? 在 Java中，异常处理的目的是使用尽可能精简的代码
创建大型、可靠的应用程序，同时排除程序里那些不
能控制的错误。通过本节学习，使我们主要学习了如
下主要内容,
– 异常的概念
– 异常的分类
– 声明异常
– 抛出异常
– 捕获并处理异常
– 自定义异常类