异常捕获及处理.docx
《异常捕获及处理.docx》由会员分享，可在线阅读，更多相关《异常捕获及处理.docx（14页珍藏版）》请在冰豆网上搜索。
异常捕获及处理
1、课程名称：
异常的捕获及处理
2、知识点
2.1、上次课程的主要知识点
1、Object类的作用；
2、链表的操作；
3、匿名内部类的定义及；
4、包装类的作用；
5、JDK1.5新特性。
2.2、本次预计讲解的知识点
1、异常的产生及主要问题；
2、异常处理的流程；
3、异常类的组成结构以及标准的异常处理格式；
4、断言的使用；
5、自定义异常类。
3、具体内容
3.1、认识异常（重点）
在程序之中异常是导致程序中断执行的一种指令流，一旦产生了异常之后，程序将立刻终止执行，在最早的时候，如果要想避免异常，则需要编写大量的if…else语句进行更加合理的判断，但是Java中引入了异常处理机制之后，对于此类问题就变的相当容易了，但是，先来观察一下异常的产生效果：
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
inttemp=10/3;//进行除法计算
System.out.println（"计算结果：
"+temp）;
System.out.println（"=====计算结束====="）;
}
}
程序输出：
=====计算开始=====
计算结果：
3
=====计算结束=====
现在的程序之中没有发生任何的意外情况，所以最终的结果是正常的，但是下面修改一下程序。
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
inttemp=10/0;//进行除法计算
System.out.println（"计算结果：
"+temp）;
System.out.println（"=====计算结束====="）;
}
}
输出结果：
=====计算开始=====
Exceptioninthread"main"java.lang.ArithmeticException:
/byzero
atTestDemo.main（TestDemo.java:
4）
程序在计算处出现了异常，所以出现异常之后的代码不再执行了，即：
程序被中断了。
3.2、异常处理的格式（重点）
如果异常出现之后没有进行合理的操作，则程序将会中断执行，则这个时候就可以通过如下的格式进行异常的处理，这样保证在程序出现异常的时候也不会中断程序。
try{
有可能出现异常的语句
}catch（异常类异常类对象）{
异常的处理
}[catch（异常类异常类对象）{
异常的处理
}..][finally{
异常处理的出口
}]
范例：
在程序中使用异常处理
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
try{
inttemp=10/0;//进行除法计算
System.out.println（"计算结果：
"+temp）;
}catch（ArithmeticExceptione）{
System.out.println（e）;
}
System.out.println（"=====计算结束====="）;
}
}
加入异常处理之后，程序可以正常的执行完毕，
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
try{
inttemp=10/2;//进行除法计算
System.out.println（"计算结果：
"+temp）;
}catch（ArithmeticExceptione）{
e.printStackTrace（）;//打印异常信息最全
}
System.out.println（"=====计算结束====="）;
}
}
不管在何处，只要异常产生了，则异常产生之后的语句都不再执行，而且一旦有异常之后，肯定要跑到相应的catch语句之中执行，如果现在没有异常，则程序可以正常的执行完毕。
在异常的处理语句之中，也可以加上finally，这样不管是否出现异常，则最终都会执行此操作。
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
try{
inttemp=10/0;//进行除法计算
System.out.println（"计算结果：
"+temp）;
}catch（ArithmeticExceptione）{
e.printStackTrace（）;//打印异常信息最全
}finally{
System.out.println（"都会执行。
"）;
}
System.out.println（"=====计算结束====="）;
}
}
而且一个try语句之后可以同时捕获多种类型的异常。
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
try{
intx=Integer.parseInt（args[0]）;
inty=Integer.parseInt（args[1]）;
inttemp=x/y;//进行除法计算
System.out.println（"计算结果：
"+temp）;
}catch（ArithmeticExceptione）{
e.printStackTrace（）;//打印异常信息最全
}catch（ArrayIndexOutOfBoundsExceptione）{
e.printStackTrace（）;
}catch（NumberFormatExceptione）{
e.printStackTrace（）;
}finally{
System.out.println（"都会执行。
"）;
}
System.out.println（"=====计算结束====="）;
}
}
本程序有如下几种异常：
·如果程序没有输入参数，则出现：
ArrayIndexOutOfBoundsException
·如果输入的参数不是数字，则出现：
NumberFormatException
这个程序之中现在的确处理了多个异常，但是问题也非常的明显，你如何知道一个操作会有多少种异常呢？
3.3、异常的组织及处理结构（重点）
之前已经大概的清楚了异常的产生问题及处理的格式，但是实际上在java的异常之中，包含的范围有两点：
程序中的异常、另外一个表示的是系统的错误，而这两点有时候为了省事，才直接将其都统一称为异常，而Java之中的类的继承结构里面也可以发现Throwable类，里面分为两个子类：
·Exception：
表示程序中出现的代码异常，由开发人员进行处理；
·Error：
表示的是JVM的错误，程序开发人员无法处理。
虽然Throwable表示的范围更加的广泛，但是在实际的工作之中却很少有地方直接使用Throwable进行异常的表示，因为其表示的范围太过于宽广，所以习惯在程序中使用Exception表示所处理的异常。
但是，要想充分的发挥出以上的继承关系，还需要进一步的了解异常的处理流程。
对于java程序来讲，如果程序中一旦出现了异常，则会由JVM自动的产生一个Exception子类的对象，之后就好比方法的参数接收那样，catch语句中的异常类型要和抛出的异常对象进行比较，如果比较成功了，则认为当前抛出的这个异常满足与catch语句中的参数的类型，则表示可以使用此catch进行处理，而如果没有匹配的catch呢，则程序会认为此异常无法处理则交给JVM做默认的处理方式（中断执行）。
而最后不管是否产生了异常都会以finally的代码作为程序的出口。
既然现在已经掌握了此过程，那么对于异常的接收就可以进一步了，因为按照面向对象的多态性来讲，所有的子类的对象都可以使用父类接收，所以在异常的处理之中，如果为了省事，可以直接Exception接收所有产生的异常类的实例化对象。
但是这样一来有一个注意点，就是捕获范围广的异常一定要放在捕获范围小的异常之后。
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"=====计算开始====="）;
try{
intx=Integer.parseInt（args[0]）;
inty=Integer.parseInt（args[1]）;
inttemp=x/y;//进行除法计算
System.out.println（"计算结果：
"+temp）;
}catch（Exceptione）{
e.printStackTrace（）;
}finally{
System.out.println（"都会执行。
"）;
}
System.out.println（"=====计算结束====="）;
}
}
以上这种简便的做法只适合于异常情况处理要求简单的条件下，如果现在开发要求中需要将每个异常分别处理的话，则就必须采用多个catch语句的形式了。
3.4、throws关键字（重点）
在异常的处理之中，throws关键字主要是用于方法的声明上的，一旦在方法上使用了throws关键字之后，则表示此方法出现的异常不是由此方法自己处理，而是交给被调用处完成。
classMyMath{
publicintdiv（intx,inty）throwsException{
returnx/y;
}
}
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
try{
System.out.println（newMyMath（）.div（10,0））;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
方法本身不再进行任何的异常处理，而是要将异常交给被调用处完成，但是此时调用处由于不确定方法中最终是否会产生异常，所以必须按照有可能产生异常的方式来进行处理。
当然，主方法由于本身也是方法，所以也可以继续使用throws。
classMyMath{
publicintdiv（intx,inty）throwsException{
returnx/y;
}
}
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）throwsException{
System.out.println（newMyMath（）.div（10,0））;
}
}
如果程序中出现了异常，则表示将交给JVM继续进行异常的处理。
3.5、throw关键字（重点）
之前讲解过，如果程序中一旦产生了异常之后，将自动生成一个异常类的实例化对象，但是在java之中也可以自己手工的抛出一个异常，就使用throw关键字即可。
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
try{
thrownewException（"自己抛着玩的。
"）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
3.6、异常处理的标准格式（核心重点）
try….catch…finally、throw、throws实际上就将构成异常处理的标准格式。
要求：
div（）方法在进行计算之前和之后必须有信息输出，而且一旦发生了异常之后应该交给被调用处处理。
classMyMath{
publicintdiv（intx,inty）throwsException{
System.out.println（"=========计算开始==========="）;
inttemp=0;
try{
temp=x/y;
}catch（Exceptione）{
throwe;//把异常向上抛
}finally{
System.out.println（"=========计算结束==========="）;
}
returntemp;
}
}
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
try{
System.out.println（newMyMath（）.div（10,0））;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
3.7、RuntimeException（重点）
将字符串变为int型数据所依靠的方法：
publicstaticintparseInt（Strings）throwsNumberFormatException
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
intx=Integer.parseInt（"123"）;
System.out.println（x）;
}
}
以上的parseInt（）方法上明明使用了throws关键字，但是发现在调用的时候却可以不使用try…catch进行处理，这是为什么呢？
观察NumberFormatException类的继承关系：
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.IllegalArgumentException
java.lang.NumberFormatException
NumberFormatException是RuntimeException类的子类，而RuntimeException类的子类的异常在开发之中如果使用了throws抛出，则可以根据自己的需要任意选择是否使用try…catch处理，如果没有使用try…catch，那么一旦产生了异常之后，则就将由JVM自己进行处理了。
面试题：
请解释Exception和RuntimeException类的区别？
RuntimeException是Exception的子类，表示的是运行时异常；
Exception类型的异常如果抛出，则必须进行异常的处理，而RuntimeException类型的异常，可以根据自己的实际情况来决定是否处理，不处理也没有关系。
3.8、断言：
assert（了解）
断言：
很肯定的判断性的语句；
断言是在JDK1.4之后增加的一个新功能，使用assert关键字表示。
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
intx=10;
assertx==5;
}
}
如果按照之前的方式执行程序，断言根本就没有任何的问题，因为这个时候没有启用断言检查，而要想启用的话，则直接在java命令执行的时候使用一个“-ea”的参数即可：
java-eaTestDemo
现在只是显示除了断言错误，却不知道具体的错误信息，此时要想知道具体的，则可以修改断言的定义格式：
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
intx=10;
assertx==5:
"x==5";
}
}
3.9、自定义异常类（了解）
Java本身已经提供了足够多的异常类的信息，但是在实际的工作开发之中，有可能根据自己的情况希望定义属于用户自己的异常类，这个时候就需要自定义异常类，而这个异常类在定义的时候就需要继承Exception类。
classMyExceptionextendsException{
publicMyException（Stringmsg）{
super（msg）;
}
}
publicclassTestDemo{
publicstaticvoidmain（Stringargs[]）{
try{
thrownewMyException（"自己抛着玩的。
"）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
但是这种操作一般很少会直接使到，因为java中所提供的异常类已经足够使了，所以，这个就作为一种概念知道了即可，不用费劲琢磨。
4、总结
1、各个关键字的使用；
2、RuntimeException和Exception的区别；
3、异常处理的标准格式。
5、预习任务
包及访问控制权限、多线程的两种实现形式、同步与死锁的概念。
6、作业
复习全部的代码。
升级会员 