java异常处理.docx
《java异常处理.docx》由会员分享，可在线阅读，更多相关《java异常处理.docx（24页珍藏版）》请在冰豆网上搜索。
java异常处理
1.纲要
1.异常的基本概念
2.异常的分类
3.异常的捕获和处理
4.自定义异常
5.方法覆盖与异常
2、内容
1.12.1、异常的基本概念
什么是异常，在程序运行过程中出现的错误，称为异常
publicclassExceptionTest01{
publicstaticvoidmain（String[]args）{
inti1=100;
inti2=0;
inti3=i1/i2;
System.out.println（i3）;
}
}
没有正确输出，抛出了被0除异常
通过以上示例，我们看到java给我们提供了这样一个体系结构，当出现问题的时候，它会告诉我们，并且把错误的详细信息也告诉我们了，这就是异常的体系结构，这样我们的程序更健壮，我们可以把这个信息，再进行处理以下告诉用户。
从上面大家还可以看到，java异常都是类，在异常类中会携带一些信息给我们，我们可以通过这个类把信息取出来
1.22.2、异常的分类
1.2.12.2.1、异常的层次结构
1.2.22.2.2、异常的分类
异常主要分为：
错误、一般性异常（受控异常）、运行期异常（非受控异常）
●错误：
如果应用程序出现了Error，那么将无法恢复，只能重新启动应用程序，最典型的Error的异常是：
OutOfMemoryError
●受控异常：
出现了这种异常必须显示的处理，不显示处理java程序将无法编译通过
●非受控异常：
此种异常可以不用显示的处理，例如被0除异常，java没有要求我们一定要处理
1.2.32.3.1、try、catch和finally
异常的捕获和处理需要采用try和catch来处理，具体格式如下：
try{
}catch（OneExceptione）{
}catch（TwoExceptione）{
}finally{
}
●try中包含了可能产生异常的代码
●try后面是catch，catch可以有一个或多个，catch中是需要捕获的异常
●当try中的代码出现异常时，出现异常下面的代码不会执行，马上会跳转到相应的catch语句块中，如果没有异常不会跳转到catch中
●finally表示，不管是出现异常，还是没有出现异常，finally里的代码都执行，finally和catch可以分开使用，但finally必须和try一块使用，如下格式使用finally也是正确的
try{
}finally{
}
【示例代码】
publicclassExceptionTest02{
publicstaticvoidmain（String[]args）{
inti1=100;
inti2=0;
//try里是出现异常的代码
//不出现异常的代码最好不要放到try作用
try{
//当出现被0除异常，程序流程会执行到“catch（ArithmeticExceptionae）”语句
//被0除表达式以下的语句永远不会执行
inti3=i1/i2;
//永远不会执行
System.out.println（i3）;
//采用catch可以拦截异常
//ae代表了一个ArithmeticException类型的局部变量
//采用ae主要是来接收java异常体系给我们new的ArithmeticException对象
//采用ae可以拿到更详细的异常信息
}catch（ArithmeticExceptionae）{
System.out.println（"被0除了"）;
}
}
}
1.2.42.3.2、getMessage和printStackTrace（）
如何取得异常对象的具体信息，常用的方法主要有两种：
⏹取得异常描述信息：
getMessage（）
⏹取得异常的堆栈信息（比较适合于程序调试阶段）：
printStackTrace（）;
【代码示例】
publicclassExceptionTest03{
publicstaticvoidmain（String[]args）{
inti1=100;
inti2=0;
try{
inti3=i1/i2;
System.out.println（i3）;
}catch（ArithmeticExceptionae）{
//ae是一个引用，它指向了堆中的ArithmeticException
//通过getMessage可以得到异常的描述信息
System.out.println（ae.getMessage（））;
}
}
}
【代码示例】
publicclassExceptionTest04{
publicstaticvoidmain（String[]args）{
method1（）;
}
privatestaticvoidmethod1（）{
method2（）;
}
privatestaticvoidmethod2（）{
inti1=100;
inti2=0;
try{
inti3=i1/i2;
System.out.println（i3）;
}catch（ArithmeticExceptionae）{
//ae是一个引用，它指向了堆中的ArithmeticException
//通过printStackTrace可以打印栈结构
ae.printStackTrace（）;
}
}
}
1.2.52.3.3、受控异常
importjava.io.FileInputStream;
publicclassExceptionTest05{
publicstaticvoidmain（String[]args）{
FileInputStreamfis=newFileInputStream（"test.txt"）;
}
}
从上面输出可以看到，无法编译，它抛出了一个异常，这个异常叫做“受控异常”FileNotFoundException，也就是说在调用的时候必须处理文件不能找到
处理FileNotFoundException
/*
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
*/
importjava.io.*;
publicclassExceptionTest06{
publicstaticvoidmain（String[]args）{
try{
FileInputStreamfis=newFileInputStream（"test.txt"）;
}catch（FileNotFoundExceptionffe）{//此异常为受控异常，必须处理
ffe.printStackTrace（）;
}
}
}
1.2.62.3.4、finally关键字
finally在任何情况下都会执行，通常在finally里关闭资源
【示例代码】
importjava.io.*;
publicclassExceptionTest07{
publicstaticvoidmain（String[]args）{
try{
FileInputStreamfis=newFileInputStream（"test.txt"）;
System.out.println（"-------beforefis.close--------"）;
//close是需要拦截IOException异常
//在此位置关闭存在问题，当出现异常
//那么会执行到catch语句，以下fis.close永远不会执行
//这样个对象永远不会得到释放，所以必须提供一种机制
//当出现任何问题，都会释放相应的资源（恢复到最初状态）
//那么就要使用finally语句块
fis.close（）;
System.out.println（"-------afterfis.close--------"）;
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
采用finally来释放资源
importjava.io.*;
publicclassExceptionTest08{
publicstaticvoidmain（String[]args）{
//因为fis的作用域问题，必须放到try语句块外,局部变量必须给初始值
//因为是对象赋值为null
FileInputStreamfis=null;
try{
//FileInputStreamfis=newFileInputStream（"test.txt"）;
fis=newFileInputStream（"test.txt"）;
/*
System.out.println（"-------beforefis.close--------"）;
fis.close（）;
System.out.println（"-------afterfis.close--------"）;
*/
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}finally{
try{
System.out.println（"-------beforefis.close--------"）;
//放到finally中的语句，程序出现任何问题都会被执行
//所以finally中一般放置一些需要及时释放的资源
fis.close（）;
System.out.println（"-------afterfis.close--------"）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
}
深入finally
【代码示例】
publicclassExceptionTest09{
publicstaticvoidmain（String[]args）{
inti1=100;
inti2=10;
try{
inti3=i1/i2;
System.out.println（i3）;
return;
}catch（ArithmeticExceptionae）{
ae.printStackTrace（）;
}finally{
//会执行finally
System.out.println（"----------finally---------"）;
}
}
}
深入finally
publicclassExceptionTest10{
publicstaticvoidmain（String[]args）{
inti1=100;
inti2=10;
try{
inti3=i1/i2;
System.out.println（i3）;
//return;
System.exit（-1）;//java虚拟机退出
}catch（ArithmeticExceptionae）{
ae.printStackTrace（）;
}finally{
//只有java虚拟机退出不会执行finally
//其他任何情况下都会执行finally
System.out.println（"----------finally---------"）;
}
}
}
深入finally
publicclassExceptionTest11{
publicstaticvoidmain（String[]args）{
intr=method1（）;
//输出为：
10
System.out.println（r）;
}
/*
privatestaticintmethod1（）
{
bytebyte0=10;
bytebyte3=byte0;//将原始值进行了保存
bytebyte1=100;
returnbyte3;
Exceptionexception;
exception;
bytebyte2=100;
throwexception;
}
*/
privatestaticintmethod1（）{
inta=10;
try{
returna;
}finally{
a=100;
}
}
}
深入finally
publicclassExceptionTest12{
publicstaticvoidmain（String[]args）{
intr=method1（）;
//输出为：
100
System.out.println（r）;
}
/*
privatestaticintmethod1（）
{
bytebyte0=10;
byte0=50;
byte0=100;
breakMISSING_BLOCK_LABEL_18;
Exceptionexception;
exception;
byte0=100;
throwexception;
returnbyte0;
}
*/
privatestaticintmethod1（）{
inta=10;
try{
a=50;
}finally{
a=100;
}
returna;
}
}
1.2.72.3.5、final、finalize和finally？
1.2.82.3.6、如何声明异常
在方法定义处采用throws声明异常，如果声明的异常为受控异常，那么调用方法必须处理此异常
【示例代码】，声明受控异常
importjava.io.*;
publicclassExceptionTest13{
publicstaticvoidmain（String[]args）
//throwsFileNotFoundException,IOException{//可以在此声明异常，这样就交给java虚拟机处理了，不建议这样使用
throwsException{//可以采用此种方式声明异常，因为Exception是两个异常的父类
/*
//分别处理各个异常
try{
readFile（）;
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
*/
//可以采用如下方式处理异常
//因为Exception是FileNotFoundException和IOException的父类
//但是一般不建议采用如下方案处理异常，粒度太粗了，异常信息
//不明确
/*
try{
readFile（）;
}catch（Exceptione）{
e.printStackTrace（）;
}
*/
readFile（）;
}
privatestaticvoidreadFile（）
throwsFileNotFoundException,IOException{//声明异常，声明后调用者必须处理
FileInputStreamfis=null;
try{
fis=newFileInputStream（"test.txt"）;
//}catch（FileNotFoundExceptione）{
//e.printStackTrace（）;
}finally{
//try{
fis.close（）;
//}catch（IOExceptione）{
//e.printStackTrace（）;
//}
}
}
}
【示例代码】，声明非受控异常
publicclassExceptionTest14{
publicstaticvoidmain（String[]args）{
//不需要使用try...catch..，因为声明的是非受控异常
//method1（）;
//也可以拦截非受控异常
try{
method1（）;
}catch（ArithmeticExceptione）{
e.printStackTrace（）;
}
}
//可以声明非受控异常
privatestaticvoidmethod1（）throwsArithmeticException{
inti1=100;
inti2=0;
//try{
inti3=i1/i2;
System.out.println（i3）;
/*
}catch（ArithmeticExceptionae）{
ae.printStackTrace（）;
}
*/
}
}
1.2.92.3.7、如何手动抛出异常
publicclassExceptionTest15{
publicstaticvoidmain（String[]args）{
intret=method1（1000,10）;
if（ret==-1）{
System.out.println（"除数为0"）;
}
if（ret==-2）{
System.out.println（"被除数必须为1~100之间的数据"）;
}
if（ret==1）{
System.out.println（"正确"）;
}
//此种方式的异常处理，完全依赖于程序的返回
//另外异常处理和程序逻辑混在一起,不好管理
//异常是非常，程序语句应该具有一套完成的异常处理体系
}
privatestaticintmethod1（intvalue1,intvalue2）{
if（value2==0）{
return-1;
}
if（!
（value1>0&&value1<=100））{
return-2;
}
intvalue3=value1/value2;
System.out.println（"value3="+value3）;
return1;
}
}
采用异常来处理参数非法
publicclassExceptionTest16{
publicstaticvoidmain（String[]args）{
//intret=method1（10,2）;
//System.out.println（ret）;
/*
try{
intret=method1（1000,10）;
System.out.println（ret）;
}catch（IllegalArgumentExceptioniae）{
//ide为指向堆中的IllegalArgumentException对象的地址
System.out.println（iae.getMessage（））;
}
*/
try{
intret=method1（1000,10）;
System.out.println（ret）;
}catch（Exceptioniae）{//可以采用Exception拦截所有的异常
System.out.println（iae.getMessage（））;
}
}
privatestaticintmethod1（intvalue1,intvalue2）{
if（value2==0）{
////手动抛出异常
thrownewIllegalArgumentException（"除数为0"）;
}
if（!
（value1>0&&value1<=100））{
//手动抛出异常
thrownewIllegalArgumentException（"被除数必须为1~100之间的数据"）;
}
intvalue3=value1/value2;
returnvalue3;
}
}
throws和throw的区别？
thorws是声明异常，throw是抛出异常
进一步了解throw
publicclassExceptionTest17{
publicstaticvoidmain（String[]args）{
try{
intret=method1（1000,10）;
System.out.println（ret）;
}catch（Exceptioniae）{
System.out.println（iae.getMessage（））;
}
升级会员 