黑马程序员—java基础 异常

5.1异常理解

1、异常：就是程序在运行时出现在非正常情况

 

2、由来：问题也是现实生活中一个具体的事物，也可以通过java的

 

类的形式进行描述，并封装成对象。其实就是java对不正常情

 

况进行描述后的对象体现

 

3、对于问题的划分两种：

 

a、一种是严重的一种是非严重的。

 

b、对于严重的，java通过Error类进行描述

 

对于Error一般不编写针对性的代码对其进行处理

 

c、对于非严重的，java 通过Exception类进行描述

 

对于Exception可以使用针对性处理方式进行处理

 

4、无论Error或Exception都具有一些共性的内容

 

比如：不正常情况的信息，引发原因等

 

5.2异常体系：

 

1、异常体系：

 

Thtrowable

 

|--Error

 

|--Exception

 

|--RuntimeException//运行时异常类

 

2、体系的特点：

 

a、异常体系中的所有类以及建立对象都具备可抛性

 

b、也就是说可以被throw和throws关健字所操作

 

c、只有异常体系具备这个特点

 

5.3异常的三种处理模块

 

1、trr{

 

需要被检测的代码；

 

}catch(异常类变量){

 

处理异常的代码，

 

}

 

2、trr{

 

需要被检测的代码

 

}finally{

 

一定会执行的语句；

 

}

 

3、trr{

 

需要被检测的代码

 

}catch(异常类变量){

 

处理异常的代码，

 

}finally{

 

一定会执行的语句；//通常用于释放资源操作

 

}

 

5.4对多异常的处理方式：

 

1、声明异常时，建议声明更为具体的异常，这样处理可以更具体；

 

2、对方声明几个异常，就对应有几个catch块

 

3、如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面

 

4、建立在进行catch处理时，catch中一定要定义具体处理方式

 

不要简单定一句e.printStackTrace(),,也不要简单的就书写一条输出语句；

 

因为项目中会出现特有的问题,而这些问题并被java所描述并封装对象；

 

所以对于这些特有的问题可以按照java的对问题封装的思想将特有的

 

问题进行自定义的异常封装。

 

5、当在函数内部出现了throw抛出异常对象，那么就必须给予对应的处理动作:

 

要么在内部try catch 处理(处理了，就不用在函数上声明了，

 

除非这个处还抛出异常)，要么在函数上声明让调用者处理。

 

6、一般情况在，函数内抛异常，函数上需要声明（除RuntimeException及其

 

子类异常外）;.

 

5.5自定义异常

 

1、如何定义异常信息呢？

 

因为父类(Throwable)中已经把异常信息的操作都完成了所以子

 

类只要在构造函数时，将异常信息传递给父类通过super语句;

 

那么就可以直接通过getMessage方法获取自定义的异常信息。

 

2、自定义异常：必须是自定义类继承Exception.

 

3、示例代码：

 

需求：在本程序中，对于除数是负数，也视为错误的是无法进行运算的，

 

那么就需要对这个问题进行自定义的描述

 

代码示例：

 

//自定义编译时一个异常类，继承Exeption

 

Class FuShuException extends Excepition{

 

Private int value;

 

FuShuExeption(String mag){

 

//因为父类Exception中已定义一个接受抛出异常时传入的信息的成员变massage;

 

//所以在这只要把信息传给父类就行了

 

Super.(mag);

 

This.value = value;

 

}

 

//可以通过从父类继成过来的toString方法打印异常信息

 

Public intgetValue(){

 

return value;

 

}

 

}

 

Class Deme{

 

//声明抛出异常对象的类型

 

Public int div(int a,int b) throws FuShuException{

 

if(b<0)

 

//抛出自定义的异常

 

Throw new FuShuException(“被除数为0了！！！”);

 

retrun a/b;

 

}

 

}

 

Class DemoTest{

 

Demo d = new Demo();

 

//下面语句可能会发生异常

 

Try{

 

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

 

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

 

//catch try块中抛出的异常，并进行相应的处理

 

}catch(FuShuException e){

 

//此方法是从父类继承的

 

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

 

System.out.println(“错误的负数是：” +e.getValue);

 

}

 

System.out.println(“over”);

 

}

 

5.6 RuntimeException:是Exception中一个特殊的子类异常，运行时异常

 

1、如果不函数内容中抛出该异常，函数上可以不用声明，编译一样通过.

 

2、如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

 

3、之所以不用在函数上声明，是因为不需要让调用者处理。

 

4、当该异常发生，希望程序停止，是因为在运行时，出现了无法继续

 

运算的情况，希望停止程序后，对代码进行修正。

 

5、自定义异常时：如该异常的发生，无法再继续进行运算时，

 

就让自定义异常继承RuntimeExcption:

 

6、示例：

 

需求：在本程序中，对于除数是负数，也视为错误的是无法进行运算的，

 

那么就需要对这个问题进行自定义的描述

 

//定义一个运行时异常；让其继承RuntimeException或及其及子类

 

Class FuShuException extends RuntimeExcepition{

 

FuShuExeption(String mag){

 

Super.(mag);//把异常信息传入

 

}

 

}

 

Class Deme{

 

//抛出运行时异常，可以不用声明

 

Public int div(int a,int b) {

 

if(b<0)

 

//抛出自定义的异常

 

Throw new FuShuException(“被除数出现负数了！！！”);

 

if(b==0)

 

//也是RuntimeException类对象.

 

Throw new ArithmeticException(“初0除了”);

 

retrun a/b;

 

}

 

}

 

Class DemoTest{

 

Demo d = new Demo();

 

//下面语句可能会发生RuntimeException类的异常,但不用处理

 

Int x = d.div(4,-5);

 

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

 

System.out.println(“over”);

 

}

 

5.7异常在子父类覆盖中的体现:

 

1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的

 

覆盖方法时，只能抛出父类的异常或者该异常的子类。

 

如：

 

class AException extends Exception{

 

}

 

class BException extends AException{

 

}

 

class CException extends Exception{

 

}

 

class Fu{

 

Void show() throws AException{

 

}

 

}

 

class Zi extends Fu{

 

//子类要么不抛异常，要么只能抛AException,BException,

 

//不能抛其他的异常类。

 

//如不能抛CException

 

Void show()throws AExcepiton{

 

}

 

}

 

Class Test{

 

//如果这里接收的是子类对象，且子类对象抛出的是CException

 

Void function(Fu f){

 

Try{

 

f.show();

 

//那么这里就有问题了

 

//也就是说早期的程序(Test)，不能处理后期程序(Zi)的

 

//新异常(CException)

 

//所以不让子类抛出新的异常（也就是说只能抛父类抛出的异

 

//常或该异常的子类）

 

}catch(AException e){

 

}

 

}

 

}

 

class ExceptionTest{

 

public static void main(String[] args){
Test t = new Test();

 

t.funtion(new Zi());

 

}

 

}

 

Exceprion

 

|--AException

 

|--BException

 

|--CException

 

2、如果父类方法抛出多个异常，那么子类在覆盖父类方法是，

 

只能抛出父类异常的子集。

 

如父抛出：A B C D E；子类只能抛出：ABCD E；A B C ；BCDE，

 

只要不超过父类都行。

 

3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，

 

也不能抛出异常，如果子类真发生了异常，就必须进行try处理，

 

绝对不能抛出。

 

注意：

 

1、finally 中定义的通常是关闭资源代码，因为资源必须释放，

 

2、finaly只有一种情况不会执行，当执行到System.exit(0); finally不会执行

 

3、catch是用于处理异常，如果没有catch就代表异常没胡被处理过，如果该异常是检测时(编译时，

 

非RuntimeExeption及其子类的异常)异常，那么必须声明

 

总结：

 

异常的好处：

 

1、将问题进行封装

 

2、将正常流程代码和问题处理代码分离，方便阅读。

 

异常的处理原则：

 

1、处理方式有两种：try或throws

 

2、调用到抛出异常的功能时，抛出几个，就处理几个

 

一个try对应一个catch.

 

3、多个catch，父类的catch放到后面。

 

4、catch内，需要定义针对性的处理方式，

 

不要简单的定义printStackTrace.输出语句

 

5、当捕获到的异常，本功能处理不了时，要以继续在catch中抛出

 

try{

 

throw new AException();

 

}catch(AException e){

 

throw a;

 

}

 

6、如要该异常处理不了，但并不属于该功能出现的的异常。

 

可以将异常转换后，在抛出和该项功能相关的异常

 

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去

 

try{

 

throw new AException();

 

}catch(AException e){

 

//对AException处理

 

throw new BException();

 

}