java异常处理机制3精.docx
《java异常处理机制3精.docx》由会员分享，可在线阅读，更多相关《java异常处理机制3精.docx（14页珍藏版）》请在冰豆网上搜索。
java异常处理机制3精
java异常处理机制
一、什么是java的异常？
异常是导致程序中断运行的一种指令流，软件和硬件错误都可能导致异常的产生，用户输入错误，所需要的文件找不到，运行时磁盘空间不够，内存不够，算术运算错误（数的溢出、被零除），数组下标越界……
模仿一个异常:
packagecom.destiny;
publicclassException{
publicstaticvoidmain（String[]args{
System.out.println（"********开始计算****************";
inti=10;
intj=0;
intm=i/j;//出现异常
//程序中断，以下部份没有执行
System.out.println（"10除以0的结果是:
"+m;
System.out.println（"********完成计算****************";
}
}
结果:
********开始计算****************
Exceptioninthread"main"java.lang.ArithmeticException:
/byzero
atcom.destiny.Exception.main（Exception.java:
8
二、异常处理方式
异常出现后，如果没有进行合理的处理，则会让应用程序中断运行。
Try{
放置可能会出现异常的语句
}catch（异常类异常类的对象{
处理异常的语句
}catch（异常类异常类的对象{
可以有多个，是因为try中的语句可能会抛出多个不同的异常，括号中的异常类有很多，不同的类就代表不同的异常，如果异常出现了，而catch所指定的异常类不属于产生的异常，那么该异常将不会被捕捉到。
}finally{
可选的语句块，不管是否出现了异常，该语句块的语句都要执行，比如关闭数据库的连接等
}
例子:
packagecom.destiny;
publicclassException00{
publicstaticvoidmain（String[]args{
System.out.println（"********开始计算****************";
intm=0;
try{
inti=10;
intj=0;
m=i/j;
}catch（ArithmeticExceptione{
System.out.println（"异常被捕捉";
e.printStackTrace（;
}finally{
System.out.println（"finally中的语句被执行";
}
}
}
结果:
********开始计算****************
java.lang.ArithmeticException:
/byzero
异常被捕捉
atcom.destiny.Exception00.main（Exception00.java:
10
finally中的语句被执行
注意:
以上代码如果catch块声明成catch（NumberFormatExceptione，则异常将不会被捕捉，也不会被处理，但finally块中的代码也会被执行。
packagecom.destiny;
publicclassException00{
publicstaticvoidmain（String[]args{
System.out.println（"********开始计算****************";
intm=0;
try{
inti=10;
intj=0;
m=i/j;
}catch（NumberFormatExceptione{
System.out.println（"异常被捕捉";
e.printStackTrace（;
}finally{
System.out.println（"finally中的语句被执行";
}
}
}
结果:
********开始计算****************
finally中的语句被执行
Exceptioninthread"main"java.lang.ArithmeticException:
/byzero
atcom.destiny.Exception00.main（Exception00.java:
10
三、异常处理机制
在整个的java异常处理中，实际上也是按照面向对象的方式进行处理的，一旦产生异常，则首先会产生一个异常类的实例化对象。
我们可以在try语句中对此异常进行捕捉。
产生的异常对象与catch中的各个异常类型进行匹配，如果匹配成功，则执行catch块中的语句。
如果有finally语句，则最后执行finally中的语句。
例子：
publicclassTest{
publicstaticvoidmain（String[]args
{
inttemp;
try{
inti=13;
intj=0;
temp=i/j;
System.out.println（"i/j="+temp;
}catch（RuntimeExceptione{
e.printStackTrace（;
}
System.out.println（"---------异常处理结束---------";
System.out.println（"--------程序最后的语句---------";
}
}
结果:
java.lang.ArithmeticException:
/byzero
atTest.main（Test.java:
8
---------异常处理结束---------
--------程序最后的语句---------
--------------------------------------------------------------------------------------------------------------------------------
publicclassTest{
publicstaticvoidmain（String[]args
{
inttemp;
try{
inti=13;
intj=0;
temp=i/j;
System.out.println（"i/j="+temp;
}catch（RuntimeExceptione{
e.printStackTrace（;
}finally{
System.out.println（"---------异常处理结束---------";
}
System.out.println（"--------程序最后的语句---------";
}
}
结果:
java.lang.ArithmeticException:
/byzero
atTest.main（Test.java:
8
---------异常处理结束---------
--------程序最后的语句---------
四、java语言中错误和异常类
图解:
Throwable类是所有java语言中所有错误或异常的超类，所有异常类型都是Throwable的子类.
Exception类是用户程序可能捕捉的异常类的超类，也是用来创建用户自定义异常类型的超类。
Error用于指示合理的应用程序不应该试图捕获的严重问题，它一般是由于硬件问题产生的。
Exception又可分为两类：
RuntimeException:
运行时异常，它表示程序正常运行的话就不会产生的异常。
这种异常不用在程序中把他们列出来，运行时有问题，会自动被JVM抛出。
比如空指针异常，数组越界。
非运行时异常：
例如，FileNotFoundException异常，java编译器要求在程序中必须进行处理，抛出这类异常除外。
例子:
以下为非运行时异常的例子，此种异常在写代码的时候，IDE就会提示要求必须进行捕捉。
importjava.io.*;
importjava.io.FileNotFoundException;
importjava.util.*;
publicclassForOne{
publicstaticvoidmain（String[]args{
Filefile=newFile（"d:
/temp/gundam.txt";
try{
FileInputStreamfis=newFileInputStream（file;
}catch（FileNotFoundExceptione{
e.printStackTrace（;
}
}
}
结果:
java.io.FileNotFoundException:
d:
\temp\gundam.txt（系统找不到指定的文件。
atjava.io.FileInputStream.open（NativeMethod
atjava.io.FileInputStream.（FileInputStream.java:
106
atForOne.main（ForOne.java:
9
运行时的异常在编译时是发现不了的，必须由程序员自己来判断。
提示：
所有需处理的异常，我们都可以用Exception类来进行捕捉。
五、通过方法抛出异常
如果我们不打算处理方法中的异常，可以用此语句把产生的异常抛出，交给调用该方法的方法去处理
此种方式可以把方法中的语句可能产生的异常进行抛出，可以抛给方法的调用者。
如果在方法声明处使用了throws声明异常，则该方法中产生的异常并不必再捕捉。
方法名称（参数列表）throws异常类型列表
importjava.io.*;
importjava.util.*;
publicclassForOne{
publicstaticvoidmain（String[]argsthrowsFileNotFoundException{
//在main上使用throws将会把异常抛出给jvm，这种方式是不允许的，jvm也不知道该如何处理这种异常
Filefile=newFile（"d:
/temp/gundam.txt";
FileInputStreamfis=newFileInputStream（file;
}
}
修改后:
importjava.io.*;
importjava.util.*;
publicclassForOne{
publicstaticvoidmain（String[]args{
try{
justice（;
}catch（FileNotFoundExceptione{
e.printStackTrace（;
}
}
staticvoidjustice（throwsFileNotFoundException{
Filefile=newFile（"d:
/temp/gundam.txt";
FileInputStreamfis=newFileInputStream（file;
}
}
例子:
packagecom.destiny;
publicclassException{
publicstaticvoidmain（String[]args{
intr=cal（10,0;
}
staticintcal（inti,intj{
intm=0;
m=i/j;
returnm;
}
}
和开始一样异常没有被捕捉,结果:
Exceptioninthread"main"java.lang.ArithmeticException:
/byzero
atcom.destiny.Exception.cal（Exception.java:
9
atcom.destiny.Exception.main（Exception.java:
5
将异常抛给调用它的方法:
packagecom.destiny;
publicclassException01{
publicstaticvoidmain（String[]args{
intr=cal（10,0;
}
staticintcal（inti,intjthrowsException{//向方法的调用者抛出异常
intm=0;
m=i/j;
returnm;
}
}
cal下面会有报错，抛出去后谁调用这个方法谁就要处理这个异常
packagecom.destiny;
publicclassException01{
publicstaticvoidmain（String[]args{
try{//捕捉cal方法抛出的异常
intr=cal（10,0;
}catch（Exceptione{
System.out.println（"异常被捕捉";
e.printStackTrace（;
}
}
staticintcal（inti,intjthrowsException{//向方法的调用者抛出异常
intm=0;
m=i/j;
System.out.println（"异常已出现";//看看异常是否会被捕捉
returnm;
}
}
结果：
异常被捕捉
java.lang.ArithmeticException:
/byzero
atcom.destiny.Exception01.cal（Exception01.java:
14
atcom.destiny.Exception01.main（Exception01.java:
6
r没有赋值，即return没执行，但程序也没有中断
使用这种方法捕捉到程序产生异常后，则后面的代码不再执行
六、通过语句抛出异常
throwThrowableObject;
ThrowableObject必须是Throwable或者其子类的对象。
自定义的异常也就是用户自己定义的异常，一般用来向调用发送一些信息。
该语句用在方法体内的，用来抛出一个异常，程序在遇到此语句时将会中止，后面的语句执行不到，然后在上层调用该方法的方法中进行捕捉。
此种方式往往用于抛出用户自定义的异常。
importjava.io.*;
publicclassForTwo{
publicstaticvoidmain（String[]args{
justice（;
}
staticvoidjustice（{
System.out.println（"方法开始执行!
";
try{
thrownewException（"此异常为用户自定义的异常!
";
}catch（Exceptione{
e.printStackTrace（;
}
System.out.println（"方法结束!
";
}
}
结果:
方法开始执行!
java.lang.Exception:
此异常为用户自定义的异常!
atForTwo.justice（ForTwo.java:
9
atForTwo.main（ForTwo.java:
4
方法结束!
packagecom.destiny;
publicclassMyExceptionextendsException{
publicStringgetMessage（//重写方法
{
return"哎呀，你是怎么传的参数!
";
}
}
--------------------------------------------------------------------------------------------------------
packagecom.destiny;
publicclassException01{
publicstaticvoidmain（String[]args{
try{//捕捉cal方法抛出的异常
intr=cal（10,0;
}catch（Exceptione{
System.out.println（e.getMessage（;
}
}
staticintcal（inti,intjthrowsException{//向方法的调用者抛出异常
intm=0;
if（j==0{
thrownewMyException（;
}
m=i/j;
System.out.println（"异常已出现";//看看异常是否会被捕捉
returnm;
}
}
结果：
哎呀，你是怎么传的参数!
升级会员 