JavaSE学习笔记_8：Java异常

Java异常

 

程序在运行的过程中可能产生问题。对于问题的可以划分成两种：一种是严重的问题，一种是非严重的问题。

对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

对于非严重的，java通过Exception类进行描述。对于Exeption可以使用针对性的处理方式进行处理。

无论Error或者Exception都具备一些共性内容。

比如：不正常情况的信息，引发原因等。这两个类就可以向上抽取出一个类，形成一个体系。

Throwable

|--Error

|--...

|--Exception

|...

异常和错误的情况注意区分。

 

异常：就是其中一种问题。它是程序在运行的时候出现的不正常情况。

 

异常的由来：问题也是现实生活中一个具体的事物个体。它们也有共性，因此可以进行描述抽取成一个类。这个类就叫做异常类。

 

异常可以分为：java能够识别的异常和用户自定义的异常。

1、java能够识别的异常。

比如ArithmeticException。除数不能为0。

看下面的代码：

class Demo

{

int div(int a,int b)

{

return a/b;

}

}

class ExceptionDemo

{

public static void main(String[] args)

{

Demo d=new Demo();

int x=d.div(4,1);

System.out.println(“x=”+x);

System.out.println(“over”);

}

}

上述代码是没有问题的，正常运行出结果。但是当传入的是4,0；编译通过，但运行失败。因为运行的时候才回去算。运行时显示出一大堆信息。虚拟机默认的处理机制。问题丢给虚拟机，虚拟机就会这样处理。下面我们有java提供的特有语句进行处理。

（1）第一种格式：

try

{

需要被检测的代码；

}

Catch（Exception e）

{

处理的代码；

}

finaly

{

一定会执行的语句。

}

（2）第二种格式：

try

{

需要被检测的代码；

}

Catch（Exception e）

{

处理的代码；

}

（3）第三种格式：

try

{

需要被检测的代码；

}

finaly

{

一定会执行的语句。（即使是程序遇到return或者是throw等程序结束标志，也会执行。唯一一种情况就是程序遇到System.exit（0），不会执行。）

}

这里插入一下：final有什么用？

看一需求：客户端-程序访问数据库，而数据库在服务器（一台主机），访问数据就得连接数据库，连完后，过一段时间必须断开连接。因为服务器是一台主机，主机中就有cpu，cpu处理的程序是有限的，则必须连接之后，一段时间断开让其他客户端来连接访问数据库，所以，不敢有没有从数据库中取出数据都的断开连接。

例如：

public void method()

{

连接数据库；

数据操作；

关闭数据库；

}

增，删，改，查，可能会出现一些问题，如要删除的数据不存在。throw SQLException（）；抛完异常，程序就结束了，则关闭操作就没有被执行到。因此，没问题，能按顺序执行到，关闭数据库。出了问题就关闭不了，就在耗费资源。则：关闭数据库动作，无论数据操作是否成功，一定要关闭资源。

public void method()

{

try

{

连接数据库；

数据操作；

}

catch（SQLException e）

{

 

}

finally

{

关闭数据库；

}

}

/*

finally代码：定义一定执行的代码。

通常用于关闭资源。

*/

 

（4）第四种格式：

try

{

需要被检测的代码；

}

Catch（Exception e）

{

处理的代码；

}

Catch（Exception e）

{

处理的代码；

}

 

 

代码如下：

class Demo

{

int div(int a,int b)

{

return a/b;

}

}

class ExceptionDemo

{

public static void main(String[] args)

{

Demo d=new Demo();

try

{

int x=d.div(4,0);

System.out.println(“x=”+x);

}

Catch（Exception e）

{

System.out.println（“除0了”）；

}

System.out.println(“over”);

}

}

看图进一步掌握：

 

 

可以对捕获到的异常对象进行常见方法操作：

class Demo

{

int div(int a,int b)

{

return a/b;

}

}

class ExceptionDemo

{

public static void main(String[] args)

{

Demo d=new Demo();

try

{

int x=d.div(4,0);

System.out.println(“x=”+x);

}

Catch（Exception e）

{

System.out.println（“除0了”）；

 

//打印异常信息。Java能识别的异常有异常信息。

//如果是自定义异常，则需要自己定义异常信息。

// /by zero

System.out.println（e.getMessage()）；

 

//打印异常名、异常信息

//java.lang.ArithmeticException:/by zero

//如果是自定义类的异常信息，异常类名前面没有

//java.lang

//可知，toString（）调用了getMessage（）

System.out.println（e.toString（））；

 

//打印异常名、异常信息、异常位置。分行打印。

//java.lang.ArithmeticException:/by zero

//java.lang.ArithmeticException:/by zero

//at Demo.div(Exception.java.50)

      //atExceptionDemo.main(ExceptionDemo.java:62)

//虚拟机默认的处理机制就是调用这个方法。

e.printStackTrace（）；

}

System.out.println(“over”);

}

}

 

 

 

通常功能可能有问题，我们必须要在函数上声明。利用关键字throws,功能内可能会发生什么异常就声明什么什么异常，当然你也可以声明Exception，但是这样调用者不知道具体会发生什么问题，处理的也会没有针对性，因此，建议声明的具体一些，这样处理的也就具体一些。当我们在函数这样声明了，就表示告诉调用者这个功能是有可能发生问题的。强制调用者必须在调用的时候进行处理，否则会编译失败。处理有两种方式：一种是通过try{}catch（）{}，一种是继续在它的函数头上声明向它的上一级抛。告诉它的上一级他可能会发生异常。异常可以逐级向上抛，抛到java虚拟机就到头了。||对于多异常，一个功能可能会发生多个问题。也是类似的解决办法。唯一要注意的就是，对方声明几个异常，（这几个异常用逗号隔开）就对应有几个catch块，不要多定义。如果你非要再加个catch（Exception e）{}，这个catch块只能放在最后，否则只要发生异常，不管什么异常都由它处理了，其他若干个catch等于废话，永远执行不到，编译会失败。

 

温馨提示：建议在进行catch处理的时候，catch中一定要定义具体的处理方式。不要简单的定义一句e.printStackTrace(),或者简单的书写一条输出语句。那样的话还不如不解决（声明+处理），发生问题直接让虚拟机启动它的默认处理机制。而且，你这样用户也看懂。真发生了问题，我们会用一个硬盘文件记录下来，称之为异常日志文件。管理员/网站维护人员回去看，会去解决，调试。我们在学习异常的时候，打印是为了方便。

 

2、开发员自定义的异常。

比如：FushuException.功能中我们不允许发生的事（如除数不能为负数）、和实际情况不符合的事（如求面积不能为负）可能发生。就会产生一个问题。我们就自己定义一个异常类。在异常类出现之前，我们对此的解决办法就是通过if-else语句进行判断，但是这将会导致问题处理代码（if(){}）和正常流程代码（else{}）联系紧密，聚集在一起阅读起来很痛苦，因此异常的出现能让问题处理代码和正常流程代码相分离。

自定义异常和java识别的异常唯一区别就是：问题发生时需要手动抛出异常。利用关键字throw，如:

throw new FushuException();

（这里注意：throw和return一样也是程序结束的标志，后面不能再有语句。否则编译失败。）

唯一的特殊之处：手动抛出的异常如果在内部解决掉，函数上就不要再声明，向调用者抛。如：

class Demo

{

public void method（）

{

try

{

throw new Exception（）；

}

catch（Exception e）

{

try

{

throw e；

}

catch（）

{

}

}

}

}

其他的地方和java能够识别的异常使用相同。

 

自定义异常类必须继承Exception。Throwable这个体系有一个特点：异常类和异常对象都具备可抛性。

 

实例：

class FushuException extends Exception

{

 

}

class Demo

{

int div(int a,int b)

{

if(b<0)

Throw new FushuException();

return a/b;

}

}

class ExceptionDemo

{

public static void main(String[] args)

{

Demo d=new Demo();

try

{

int x=d.div(4,-1);

System.out.println(“x=”+x);

}

catch(FushuException e)

{

System.out.println(e.toString());

System.out.println(“除数出现负数”);

}

System.out.println（“over”）；

}

}

运行结果：

FushuException

除数出现负数了

Over

 

如何定义异常信息？

我们知道：

class Throwable 

{

private String message;

Throwable()

{

 

}

Throwable(String message)

{

this.message=message;

}

public String getMessage()

{

return message;

}

}

 

 

class Exception extends Throwable

{

private String message;

Exception()

{

 

}

Exception(String message)

{

//this.message=message;父类已做，自类没必要再做

super();

}

}

 

因此，对于自定义异常类，可以这么定义异常信息：

class FushuException extends Exception

{

//自定义异常也可以没有异常信息

FushuException（）

{

}

FushuException（String message）

{

This.message=message;

}

}

class Demo

{

int div(int a,int b)

{

if(b<0)

Throw new FushuException();

return a/b;

}

}

class ExceptionDemo

{

public static void main(String[] args)

{

Demo d=new Demo();

try

{

int x=d.div(4,-1);

System.out.println(“x=”+x);

}

catch(FushuException e)

{

System.out.println(e.toString());

System.out.println(“除数出现负数 /by fushu”);

}

System.out.println（“over”）；

}

}

运行结果：

FushuException：除数出现了负数 /by fushu

Over

 

当然我们还可以在自定义异常类中定义其他的功能。

 

3、RuntimeException

（1）对于继承了RuntimeException的java能够识别的异常类：

如果在函数上声明了，调用者可以不用解决，照样编译通过。这样的类有：ArithmeticException，ArrayIndexOutofBoundException、NullPointerException等。

（2）对于继承了RuntimeException的开发员自定义的异常类：

①　如果在函数内抛出了异常，函数上可以不用声明，编译一样通过。

②　如果在函数上声明了，调用者可以不用解决，照样编译通过。

 

对于（1）和（2）中的第二条，我们干脆就不声明了，因为你声明了，调用这就会习惯性去解决，虽说是解决了，但可能没有实质性的解决掉。这样等于将问题隐藏了。因此：自定义异常类时，如果该异常发生，程序无法再继续进行，我们想让程序停掉。那么我们就让自定义异常类继承RuntimeException。这样问题最后抛向了虚拟机。启动默认处理机制。

 

说到这：

对于异常又可以分为：

1、编译时被检测的异常。（可处理，需处理）

2、编译时不被检测的异常。（运行时异常）（不可处理）

 

4、异常经典示例

（1）毕老师用电脑上课

class Computer

{

public void run()

{

System.out.println(“电脑运行”);

}

public void reset()

{

System.out.println(“电脑重启”);

}

}

class Teacher

{

private String name;

private Computer cmpt;

Teacher(String name)

{

this.name=name;

cmpt=new Computer();

}

public void prelect()

{

cmpt.run();

System.out.println(“讲课”);

}

}

class ExceptionTest

{

public static void main(String[] args)

{

Teacher t=new Teacher(“毕老师”);

T.prelect();

}

}

编译运行：

电脑运行

上课

 

/*

开始思考上课中出现的问题。应该是电脑出现了问题，而不是老师。

比如：

电脑蓝屏

电脑冒烟

要对问题进行描述，封装成对象。

*/

class LanPingException extends Exception

{

LangPinException(String message)

{

super(message);

}

}

class MaoYanException extends Exception

{

MaoYanException(String message)

{

super(message);

}

}

class Computer

{

private int state=1;

public void run()

throws LanPinException,MaoYanException

{

if(state==2)

throw new LanPinException(“蓝屏”);

if（state==3）

throw new MaoYanException(“冒烟”);

}

public void reset()

{

state=1;

System.out.println(“电脑重启”);

}

}

class Teacher

{

private String name;

private Computer cmpt;

Teacher(String name)

{

this.name=name;

cmpt=new Computer();

}

public void prelect()throws MaoYanException

{

try

{

cmpt.run()

}

catch(LanPinException e)

{

cmpt.reset();

}

catch(MaoYanException e)

{

throw e；

}

System.out.println（“讲课”）；

}

}

class ExceptionTest

{

public static void main(String[] args)

{

Teacher t=new Teacher(“毕老师”);

Try

{

T.prelect();

}

catch(Exception e)

{

 

}

}

}

那么问题来了，这个冒烟的问题抛给了main（），它也不能处理。两者没有直接的关系。因此，在prelect（）中的第二个catch就不能抛出e。那怎么办呢？把冒烟的异常转化成授课老师的异常在抛给main（）去处理。具体为：电脑冒烟，老师就不能讲课，因此老师就产生了异常。

 

/*

当冒烟发生后，出现讲课进度无法继续。

出现了讲师问题：课时无法完成。

*/

class LanPingException extends Exception

{

LangPinException(String message)

{

super(message);

}

}

class MaoYanException extends Exception

{

MaoYanException(String message)

{

super(message);

}

}

//定义新异常类

class NoPlanException extends Exception

{

NoPlanException(String message)

{

super(message);

}

}

class Computer

{

private int state=1;

public void run()

throws LanPinException,MaoYanException

{

if(state==2)

throw new LanPinException(“蓝屏”);

if（state==3）

throw new MaoYanException(“冒烟”);

}

public void reset()

{

state=1;

System.out.println(“电脑重启”);

}

}

class Teacher

{

private String name;

private Computer cmpt;

Teacher(String name)

{

this.name=name;

cmpt=new Computer();

}

public void prelect()throws MaoYanException

{

try

{

cmpt.run()

}

catch(LanPinException e)

{

cmpt.reset();

}

catch(MaoYanException e)

{

test();

//解决不了，继续抛。

//解决得了，继续抛。抛和该功能相关的异常。

throw new NoPlanException（“课时无法继续”）；

}

System.out.println（“讲课”）；

}

public void test()

{

System.out.println(“lianxi”);

}

}

class ExceptionTest

{

public static void main(String[] args)

{

Teacher t=new Teacher(“毕老师”);

try

{

t.prelect();

}

catch(NoPlanException  e)

{

System.out.println（e.toString()）；

System.out.println(“换电脑或者换老师，不然就放假”);

}

}

}

（2）求图形面积

interface Shape

{

void getArea();

}

class Rec implements Shape

{

private int len,wid;

Res(int len,int wid)

{

this.len=len;

this.wid=wid;

}

public void getArea()

{

System.out.println(len*wid);

}

}

class ExceptionTest

{

public static void main(String[] args)

{

Rec r=new Rec(3,4);

r.getArea();

}

}

运行结果：

12

传入（3，-4）

运行结果：

-12

问题:这与现实生活中的情况不符合。于是我们用以前常用的方法来解决：

interface Shape

{

void getArea();

}

class Rec implements Shape

{

private int len,wid;

Res(int len,int wid)

{

if(len<=0||wid<=0)

System.out.println(“非法”);

else

{

this.len=len;

this.wid=wid;

}

}

public void getArea()

{

System.out.println(len*wid);

}

}

class ExceptionTest

{

public static void main(String[] args)

{

Rec r=new Rec(3,4);

r.getArea();

}

}

这种解决方案使得正常流程代码和问题处理代码聚集在一起。阅读性很差。因此定义异常类：

class NoValueException extends Exception

{

NoValueException(String message)

{

super(message);

}

}

interface Shape

{

void getArea();

}

class Rec implements Shape

{

private int len,wid;

Res(int len,int wid)throws NoValueException

{

if(len<=0||wid<=0)

Throw new NoValueException(“出现非法值”);

else

{

this.len=len;

this.wid=wid;

}

}

public void getArea()

{

System.out.println(len*wid);

}

}

class ExceptionTest

{

public static void main(String[] args)

{

try

{

Rec r=new Rec(3,4);

r.getArea();

}

catch（NoValueException e）

{

System.out.println（e.toString()）；

}

System.out.println(“over”);

}

}

但是这个问题其实我们不应该去处理，处理不当等于将问题隐藏，我们应该根据异常信息去改动程序。因此应该让NoValueException继承RuntimeException。如下所示：

class NoValueException extends RuntimeException

{

NoValueException(String message)

{

super(message);

}

}

interface Shape

{

void getArea();

}

class Rec implements Shape

{

private int len,wid;

Res(int len,int wid)throws NoValueException

{

if(len<=0||wid<=0)

Throw new NoValueException(“出现非法值”);

else

{

this.len=len;

this.wid=wid;

}

}

public void getArea()

{

System.out.println(len*wid);

}

}

class ExceptionTest

{

public static void main(String[] args)

{

Rec r=new Rec(3,4);

r.getArea();

}

}

 

 

5、异常—覆盖时的异常特点

（1）子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。或者不抛。若在子类中抛出其他异常，只能在内部解决，不能throws声明出去。

（2）如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子类。或者不抛。若在子类中抛出其他异常，只能在内部解决。不能throws声明出去。

（3）如果父类或者接口的方法中没有异常抛出，那么子类在覆盖该方法时，也不可以抛。如果子类方法可能发生异常，只能在内部解决，不能throws声明出去。

 

其实：这些规定都是由于，声明时父类声明了具体的异常，如果声明的是根异常类Exception，则没有这些规定。

 

示例：看图

 

 

 

 

 

2015-11-22至2015-11-24著