【第22期】观点:IT 行业加班,到底有没有价值?

鸟哥Java学习之异常-面向对象

转载 2016年06月01日 20:50:26
1.异常:运行时发生,
    异常类:在Java中用类的形式对不正常情况进行了描述和封装对象。

2.最终问题分成两大类:
Throwable(可抛性):
    一般不可处理(Error),可以处理的(Exception)。
可抛性通过throws(异常类的抛出,可以抛出多个,用逗号隔开,使用在函数上)、throw(异常对象的抛出,使用在函数内)关键字体现,凡是可以被这两个关键字所操作的类和对象都具有可抛性。
    自定义异常类:如果让一个类成为异常类,必须要继承异常体系(Exception),因为只有异常体系的子类才有资格具备可抛性,才可以被两个关键字操作。
    注意:自定义异常时,要么继承Exception,要么继承RuntimeException。
    异常分类:
    编译时被检测异常:Exception及其子类都是,除了特殊子类RuntimeException。
    运行时被检测异常:Exception中的RuntimeException及其子类。(开发中常见,不需要throws声明)

3.异常捕捉:给出解决异常的方法,后面的代码继续运行
    try{//需要被检测异常的代码}
    catch(异常类 变量){//处理异常的代码}
    finally{//一定会被执行的代码}
    throws抛出多个对象时,一个try对应多个catch,此时父类的catch放在最下面
    
4.异常处理原则:
    函数内部如果抛出需要检测的异常,那么函数上必须要声明。否则必须在函数内用try catch,否则编译失败。
    如果调用到了声明异常的函数,要么trycatch要么throws,否则编译失败。
    功能内容可以解决,用catch解决不了,用throws告诉调用者,由调用者解决。
    一个功能如果抛出多个异常,那么调用时必须要有对应的多个catch进行针对性处理。内部有几个需要检测的异常,就抛出几个异常,就catch几个。

5.finally{}:通常用于关闭(释放)资源,如关闭数据库连接。没有必要资源需要释放时,可以不用定义。

6.异常的注意事项:
    子类覆盖父类方法时,父类抛出异常,则子类只能抛出父类的异常或异常的子类。
    如果父类抛出多个异常,那么子类只能抛出父类异常的子集。
    如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛。只能try

7.练习
interface Graph
{
public abstract double area();
}
class illegalException extends RuntimeException//不需处理应继承RuntimeException
{
illegalException(){super();}
illegalException(String message ){super(message);}
}//若这句不写super(message),运行出不来"数值非法"提示。
class Circle implements Graph
{
static final double PI = 3.14;
private int r;
Circle(int r)//记得要初识化
{
if(r<0)
{
throw new illegalException("数值非法");
}//判断不应放在函数中
this.r=r;
}
public double area()
{
return pi*r*r;
}
}
class Rect implements Graph
{
private int length;
private int width;
Rect(int length,int width)
{
if(length<0||width<0)
{
throw new illegalException("数值非法");
}
this.length=length;
this.width=width;
}
public double area()throws illegalException
{
return length*width;
}
}
class areaTest
{
public static void main(String[] args)
{
Circle c =new Circle(-1);
Rect b =new Rect(3,2);
double x=c.area();
double y=b.area();
System.out.println(x+","+y);
}
}
详解(以下为网上摘录总结)
异常
======================
     Java的异常(包括Exception和Error)分为可查的异常(checked
 exceptions)和不可查的异常(unchecked exceptions)。
        可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常状况。可查异常虽然是异常状况,但在一定程度上它的发生是可以预计的,而且一旦发生这种异常状况,就必须采取某种方式进行处理。

      除了RuntimeException及其子类以外,其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,否则编译不会通过

        不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)
======================================
    Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

       运行时异常:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。

      运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。
       非运行时异常 (编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常。

==================================
处理异常机制
===========================
        在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。
        抛出异常:当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
        捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适
 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。
        
对于运行时异常、错误或可查异常,Java技术所要求的异常处理方式有所不同。
        由于运行时异常的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常
       对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常。
       对于所有的可查异常,Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常。
        能够捕捉异常的方法,需要提供相符类型的异常处理器。所捕捉的异常,可能是由于自身语句所引发并抛出的异常,也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常。简单地说,异常总是先被抛出,后被捕捉的。
         任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。
        从方法中抛出的任何异常都必须使用throws子句。
        捕捉异常通过try-catch语句或者try-catch-finally语句实现。
         总体来说,Java规定:对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。


===Throws抛出异常的规则:
    1) 如果是不可查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。
    2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误
    3)仅当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,而不是囫囵吞枣。

    4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

===使用throw抛出异常
   throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。
如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

===
try 块:用于捕获异常。其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
catch 块:用于处理try捕获到的异常。
finally 块:无论是否捕获或处理异常,finally块里的语句都会被执行。当在try块或catch块中遇到return语句时,finally语句块将在方法返回之前被执行。在以下4种特殊情况下,finally块不会被执行:
1)在finally语句块中发生了异常。
2)在前面的代码中用了System.exit()退出程序。
3)程序所在的线程死亡。
4)关闭CPU。

新增理解:关于throw,throws
1 两个都是抛出异常,第一个在方法体内抛出,针对具体的对象;第二个在方法上声明方法可能抛出异常的类型,便于方法调用者处理异常或继续声明抛出。
2 异常也是对象,第一个是异常抛出的实例;第二个只是一种可能,倾向,并不是真正抛出异常,所以是一种声明可能。


举报

相关文章推荐

【学习笔记17】java面向对象-异常处理:捕获异常与抛出异常

异常的处理: 方式一:捕获处理  捕获处理的格式: try{ 可能发生异常的代码; }catch(捕获的异常类型 变量名){ 处理异常的代码.... } 捕获处理要注意的细节: 1. 如果tr...

Java菜鸟学习笔记--面向对象篇(十六):Object类方法

Object类 <

(15)Java学习笔记——面向对象08——异常

异常 是在运行时期发生的不正常情况 在JAVA中用类的形式对不正常情况进行了描述和封装对象。 描述不正常的情况的类,称之为异常类。 其实异常就是java通过面向对象的思想将问题封装成对象,用异...

Java菜鸟学习笔记--面向对象篇(八):成员变量和局部变量

变量分类 <img

Java学习系列(九)Java面向对象之异常机制详解

异常处理机制用来保障我们的程序更加健壮,无论用户怎么操作,都能保证我们的程序都能正常应对的一种处理机制。 一般格式如下: try{ // 尝试让它执行业务处理,如果可以执行完成,就代表一切正常。 // 业务处理 }catch(异常1 e1){ // 进行异常1处理 }catch(异常2 e2){ // 进行异常2处理 } 举例说明1: <pre name="
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)