Java基础——异常及处理方法

什么是异常？让我们先运行一段代码来理解

class Demo
{
int chuFa(int x,int y)//这是一个除法运算
{
return x/y;
}
}
public class ExceptionDemo {
public static void main(String[] args)
{
Demo d = new Demo();
int a = d.chuFa(4,1);//这里传入的除数是1
System.out.println(a);
System.out.println("over");
}
}

运行结果如下：



而当我把主函数中的除数换成0的话，我们知道在数学中这是没有意义的运算。在Java运行时也会运行失败，提示如下：



结果表明，在程序运行的过程中出现了不正常的情况，

是什么情况不正常呢？提示中给出，ArithmeticException：/ by zero 算术异常：被0除了

我们把这样在程序中出现的不正常的情况称之为异常。

异常：就是程序在运行时出现的不正常情况。

异常由来：问题现实生活中一个具体的事物，也可以通过Java类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。（简单说就是把问题封装成了对象）（这里又体现了Java语言的封装性和面向对象的特征）

对于问题的划分，有两种，一种是严重的问题，一种是非严重的问题

对应于严重的，Java通过Error类进行描述

对于非严重的，Java通过Exception类进行描述

对于Exception，一般都会编写针对性的代码进行处理

无论Error还是Exception都具有一些共性的内容。

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

所以，Error和Exception都有一个父类叫做Throwable

异常最常见的处理方法如下：

try
{
需要被检测的代码
}
catch (异常类 变量)
{
异常的处理方式
}
finally
{
一定会执行的语句
}

try catch方法处理异常的流程

当出现异常情况后，会创建一个异常对象，这个异常情况被try检测到以后就会抛给catch，catch会做出对应的解决方式，处理完异常以后，之后的代码还可以运行到。把之前的代码加上异常处理机制后就是：

public class ExceptionDemo {
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int a = d.chuFa(4,0);//这里传入的除数是1
System.out.println(a);
}
catch (Exception e)
{
System.out.println("除零啦");
}

System.out.println("over");
}
}

运行结果就变成了：


从结果中可以看出，异常处理完之后，会继续执行下边的语句

对于异常常见的几种获取信息的方法：

String getMessage();//引发错误的原因

String toString();//异常类+引发错误的原因

void printStackTrace();//异常类+引发错误的原因+追踪错误的位置信息

声明异常用throws关键字

由于在调用方法的时候会有异常发生，导致程序停止，所以在定义方法的时候要用throws关键字声明一下会有异常情况，意思就是告诉调用该方法的人，这个方法可能会发生异常，你需要处理

作用：提高安全性，让调用和作出处理，不处理则编译失败。

对于调用了已声明了异常的方法处理方式

一旦调用了已经声明异常的方法，就必须对其作出处理，否则会编译失败

处理方式有两种：

throws ：抛出，由抛出函数的外层函数进行处理，如果处理不了，再次声明抛出可以继续往外抛，那么，抛到哪里是个头呢？

jvm虚拟机，虚拟机接收到抛出的异常之后，会使用默认的方法，让程序停掉，

try：

多异常的处理方式

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

对方声明几个异常，就 对应有几个catch块。不要定义多余的catc块。

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下边，如果父类异常catch块放在了最上边，那么虚拟机认为后边的全是废话，编译失败。

举例如下：

class Demo
{
int chuFa(int x,int y) throws ArithmeticException,ArrayIndexOutOfBoundsException //在这个方法里声明了两个异常
{
int[] arr = new int[x];
System.out.println(arr[4]);//如果数组角标越界的话会触发角标越界异常
return x/y;
}
}
public class ExceptionDemo2 {
public static void main(String[] args)
{

Demo d = new Demo();
try{
int a = d.chuFa(5,1);//这里传入参数容易引发异常
System.out.println(a);
}

catch(ArithmeticException e)//触发ArithmeticException异常的时候执行的代码块
{
System.out.println("除零了");
}
catch(ArrayIndexOutOfBoundsException e)//触发ArrayIndexOutOfBoundsException异常的时候执行的代码块
{
System.out.println("角标越界啦");
}
catch(Exception e)//这是父类异常的代码块
{
System.out.println("hahaha："+e.toString());
}
System.out.println("over");
}
}

这个时候没有发生任何异常，运行会正常结束：



当把chuFa方法中的参数改为4,1时（创建一个角标越界的异常）结果如下：



当把参数改为5，0时，（创建一个运算异常） 结果如下：



我们可以看到，放在最下边的catch块，虽然是每个异常的父类，但并没有执行，

因为代码是从上到下执行的，找到了符合条件的catch块，就不会去找其他的catch块，这样写父类的异常catch块是为了避免其他异常蹦出来中断程序，可以编译通过，也可以运行但是不建议这么写，因为在运行过程中出了啥异常都会被父类异常处理掉，如果出现了别的异常，程序员需要知道；

建议：在进行异常处理时，catch中一定要有具体的定义方式，不要简单的定义一句打印异常信息，也不要简单的书写一条输出语句

自定义异常

在后期做开发的时候，描述具体的事物有具体的要求，也就是说会遇到不同的异常，而这些是Java没有进行过描述并封装对象的

所以，对于这些特有的问题，我们可以按照Java的封装思想，将特有的问题进行自定义的异常封装。

怎么样进行异常的封装呢？我们用代码来体现：

//需求：定义一个除法运算，除了不能除零外，还要定义不能除以负数

class FuShuException extends Exception//定义一个异常类（对象），需要继承Exception
{
private int value;//想把出错误的数字也获取到，在这里创建一个value

FuShuException(String msg,int b)//因为自定义异常还没有定义自己的异常信息，所以在初始化的时候就要传一个描述性的文字，作为他的异常信息描述语句
{

super(msg);
//Exception类中已经定义了自定义异常信息的方法，这里把参数传给父类Exception就行了
//下边调用toString方法的时候会自动调用getMessage方法，将描述语句打印出来
this.value = b;

}
public int getValue()
{
return value;
}
}
class Demo
{
int chuFa(int x,int y) throws FuShuException,ArithmeticException
{
if (y<0)//除数小于0，创建异常对象并抛出
{
throw new FuShuException("除数为负数了 / by fushu",y);
}
return x/y;
}
}
public class ExceptionDemo3 {
public static void main(String[] args)
{
Demo d = new Demo();
try//对自定义的异常进行处理
{
int a = d.chuFa(4,-1);
System.out.println(a);
}
catch (FuShuException e)
{
System.out.println(e.toString()+"---错误的数字是"+e.getValue());
}
catch(ArithmeticException e)
{
System.out.println(e.toString());
}

}
}

运行结果为：



我们可以看到，自定义异常，必须是自定义类继承Exception

继承Exception 的原因：

异常体系中有一个特点，因为异常类和对象都被抛出

他们都具备可抛性。这个可抛性是Throwable这个体系中的独有特点

注意的是，在自定义异常的时候，没有必要所有的信息都自己去做，

比如异常信息的操作，在父类中就已经做完了，父类中有这样的方法：



而在Exception类中，也有相同的方法：



所以我们这里只要把自定义的信息用super语句传给父类。

就是以上代码中的 “super(msg);”

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

throw和throws的区别

throws使用在函数上，throw使用在函数内

throws后边跟的是异常类，可以跟多个，用逗号隔开

throw后跟的是异常对象

运行时异常

Exception中有一个特殊的子类异常RuntimeException

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

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

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

当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望程序停止后，对代码进行修正。

子类例如：数组角标越界异常（角标越界都找不到元素，没有办法继续运算下去了），空指针异常（对象没有指向的示例化对象，也无法进行下一步的运算）

这些情况下，我们希望程序停下来，不希望catch处理之后继续再进行运算，

因为再运算也没有什么意义了。

用一段小代码来具体体现一下RunTimeException的特点：

//运行时异常：

//需求：定义一个除法运算，除了不能除零外，还要定义不能除以负数
//一旦发生除零，除负数的情况，应该让程序停下来，因为继续算也没什么 意义了

class FuShuException extends RuntimeException//该种异常我们不会处理，发生该异常的时候希望程序停下来，所以这里要继承RunTimeException
{

FuShuException(String msg)
{
super(msg);
}

}
class Demo
{
int chuFa(int x,int y)//因为里边抛出的是RunTimeException，所以在这里可以不用声明，在主函数中也不用处理
{
if (y<0)
{
throw new FuShuException("除数为负数了 / by fushu");
}
if (y==0)
{
throw new ArithmeticException("除数为0，没意义");
}
return x/y;
}
}
public class ExceptionDemo4 {
public static void main(String[] args)
{
Demo d = new Demo();

int a = d.chuFa(4,0);
System.out.println(a);

}
}

运行结果为下图：



在自定义异常的时候：如果该异常的发生无法再继续进行运算，就让自定义异常继承RunTimeException。

对于异常分为两种：

1，编译时被检测的异常。

2，编译时不被检测的异常（运行时异常，RunTimeException以及其子类）

所以在分析问题定义异常的时候，先要分析该异常能不能被处理，

|—–如果不能处理，需要修正代码的时候，就继承RunTimeException，

|—–如果该异常可以被try catch处理，就继承Exception。

一个小练习：老师带电脑上课的过程中异常处理：

//异常练习
/*
需求：毕老师讲课，要用电脑讲课，

而会时常有异常，比如：电脑蓝屏了，：处理方式，重启，继续上课

电脑冒烟了。：处理方式，又有了一个新的异常：
课时无法完成，处理方式：换老师或者放假

思想：封装，将各种异常封装成对象，关键字提取；

*/

class LanPingException extends Exception//蓝屏异常
{
LanPingException(String msg)
{
super(msg);
}
}
class MaoYanException extends Exception//冒烟异常
{
MaoYanException(String msg)
{
super(msg);
}
}
class NoPlanException extends Exception//课时无法继续异常
{
NoPlanException(String msg)
{
super(msg);
}
}
class Teacher
{
private String name;
Teacher(String name)
{
this.name = name;
}
public void jiangKe() throws NoPlanException//老师讲课过程中会抛出课时无法继续异常，所以在这里标识一下

{
//老师来讲课，带上了自己的电脑，开启电脑之后开始讲课
Computer cmpt = new Computer();
try
{
cmpt.run();//而电脑会出现异常，所以在这里调用run方法的时候要对异常进行处理
}
catch (LanPingException e)
{
cmpt.restart();
}
catch (MaoYanException e)
{
//发生冒烟异常的时候，处理方法应该是先让学生们做练习，然后给调用讲课方法的人抛一个课时无法完成异常
//交给上一层领导处理
test();
throw new NoPlanException("课时无法继续");
}
System.out.println("开始讲课");

}
public void test()
{
System.out.println("做练习");
}
}
class Computer
{
private int state = 3;
public void run() throws MaoYanException,LanPingException
{
//电脑的诸多自定义异常都要在这里产生异常对象
if(state==2)
{
throw new LanPingException("蓝屏了");
}
if (state==3)
{
throw new MaoYanException("冒烟了");
}
System.out.println("电脑运行");
}
public void restart()
{
System.out.println("电脑重启");
}
}
public class ExceptionTest{
public static void main(String[] args)
{
Teacher t = new Teacher("毕老师");
try
{
t.jiangKe();//在调用讲课方法的时候，接收到课时无法完成异常，将在这里进行处理
}
catch (NoPlanException e)
{
System.out.println("换老师或者放假-----"+e.getMessage());
}

}
}

运行结果如下：

当代码中state为1的时候（电脑没有发生任何异常的时候）结果为：



当代码中state为2的时候（电脑发生蓝屏异常的时候）结果为：



当代码中state为3的时候（电脑发生冒烟异常的时候）结果为：



异常——finally

finally代码块，定义一定会执行的代码，通常用于关闭资源

在数据库操作中最为常见的例子：

public void method()
{
连接数据库；

数据操作//throw new SQLException如果抛出异常，下面的代码就不会运行了，也就是说资源没有被关闭，

关闭数据库//而这一步是必须要执行的
}

该代码中如果异常出现，则不会关闭资源，这不是我们想要的。

解决这样的问题可以这么做：

public void method() throws 没有操作成功异常
{
try
{
连接数据库；
数据操作；//throw new 数据操作异常；
}
catch(数据操作异常 e)
{
会对数据库异常进行处理；
throw new 没有操作成功异常；
}
finally
{
关闭数据库；
}
}

在Java中，数据存储操作是调用数据库的方法完成的，

我要存数数据，把数据给你即可，至于你是怎么存的，我没必要知道，

但是我必须知道的是：数据有没有存储成功，

就像在以上的代码中，数据库操作出现异常，应该在数据库内部直接处理，

而不是抛出来异常，因为抛出来我也看不懂，所以在你内部直接处理掉就可以了。

但是你要告诉我，有没有存储成功，也就是说这里可以抛出来一个“没有操作成功异常”这个我可以处理。

而不管有没有存储成功，资源是必须要关闭的，所以我们在这里把关闭资源的动作放在finally语句中。

异常处理语句的其他格式：

//第一种格式：
try
{
}
catch()
{
}
//第二种格式：
try
{
}
caatch()
{
}
finally
{
}
//第三种格式
try
{
}
finally
{
}

记住一点：catch是用来处理异常的，如果没有catch代表该异常没有被处理过，如果该异常时检测时异常，那么必须申明。

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

子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常，或者父类异常的子类，

如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法抛出了异常吗，就必须要进行try处理，绝对不能抛。

用一个代码练习来说明这段文字：

//异常之间的关系是：
//   |--Exception
//      |--AException
//          |--BException
//      |--CException
class AException extends Exception
{

}
class BException extends AException
{

}
class CException extends Exception
{

}

class Fu
{
public void show() throws AException//父类方法抛出一个AException
{
}
}
class Zi extends Fu//子类继承父类
{
public void show()throws BException//在这里抛出一个AException(也可以抛出BException，但是不能抛出CException)
//如果这里真的会冒出一个C异常的话，只能try，绝对不能抛
{

}
}
class Test1
{
public void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{

}

}
}
public class Test {
public static void main(String[] args)
{

Test1 t1 = new Test1();
t1.function(new Zi());
}
}

通过一串小代码来更加熟练的运用一下异常的处理机制：

//长方形圆形的面积计算程序

/*
首先思考：长方形，圆形都是图形，都有获取面积的这样一个功能，
但是长和宽是长方形特有的，半径是圆特有的属性
可以将获取面积的方法封装在一个接口中
*/
interface Shape
{
void getArea();
}
//长方形的计算过程：
class ChangFangXing implements Shape
{
private int chang;
private int kuang;
ChangFangXing(int chang,int kuang)
{
this.chang = chang;
this.kuang = kuang;
}
public void getArea()
{
//如果给出的值小于0的话，必须停掉程序，不可以再往下运行了。
if (chang<=0 || kuang<=0)
{
throw new NoValueException("长或宽的值小于0！！！");
}
System.out.println(chang*kuang);
}

}
//圆的面积计算过程：
class Yuan implements Shape
{
private int radiu;
//PI的值是不变的，所以在这里把他定义成常量
public static final double PI = 3.14;
Yuan(int radiu)
{
this.radiu = radiu;
}
public void getArea()
{
//同样的，如果他的半径小于0，程序停掉
if (radiu<=0)
{
throw new NoRadiuException("圆的半径值出错！！！");
}
System.out.println(radiu*radiu*PI);
}
}
class NoValueException extends RuntimeException
{
NoValueException(String msg)
{
super(msg);
}
}
class NoRadiuException extends RuntimeException
{
NoRadiuException(String msg)
{
super(msg);
}
}
public class ExceptionTest2 {
public static void main(String[] args)
{
//创建一个长方形对象，求面积
ChangFangXing cfx = new ChangFangXing(3,4);
cfx.getArea();
//创建一个圆的对象，并求面积
Yuan y = new Yuan(2);
y.getArea();
}
}

运算结果为：

异常知识总结：

异常是什么？

是对问题的描述，并将问题对象封装成对象

异常体系：

Throwable

Error

Exception

RuntimeException

异常体系的特点：异常体系中所有类以及建立的对象都具有可抛性。也就是说可以被throw和throws关键字操作，只有异常体系具备这个特点。

throw和throws的用法：

throw定义在函数内，用于抛出异常对象

throws定义在函数上，用于抛出异常类，可以抛出多个，用逗号隔开。

当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败

注意：RunTimeException除外，也就是说，函数中如果抛出RunTimeException函数上可以不用声明

如果函数上声明了异常，调用者需要进行处理。处理方法可以是try和throws

异常有两种：

编译时被检测异常

该异常在编译时，如果没有进行过处理（没有抛也没有try），编译失败

该异常被标识，代表着可以被处理

运行时异常（编译时不检测）

在编译时，不需要处理，编译器不检查。

该异常发射给你时，建议不处理，让程序停止，需要对代码进行修正

异常处理语句：

try

{

需要被检测的代码；

}

catch（）

{

处理异常的代码；

}

finally

{

一定会执行的代码；

}

有三个结合方式：

1.try catch

2.try finally

3.try catch finally

注意：

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

finally只有一种情况不会执行，当执行到System.exit(0)；finally不会执行，因为jvm结束运行了

自定义异常：

定义类继承Exception或者RuntimeException

1.为了让该自定义类具备可抛性。

2.让该类具备操作异常的共性方法

3.当要定义自定义异常信息时，可以使用父类已经定义好的功能。将异常信息传递给父类的构造函数

class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}

自定义异常：按照Java面向对象的思想，将程序中出现的特有问题进行封装

异常的好处：

将问题进行封装。

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

异常的处理原则：

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

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

一个try对应多个catch

3，多个catch，父类的catch放到最下边

4，catch内，不需要定义针对性的处理方式，不要简单的定义printstrackTrace,也不要不写

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

try
{
throw new AException();
}
catch(AException e)
{
throw e
}

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

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

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

让调用者知道，并处理，也可以将捕获异常处理后，转换新的异常抛出

try
{
throw new AException();
}
catch(AException e )
{
//对AException处理。
throw new BException();
}

比如：汇款的例子。

我去给张三汇款，但是出了异常没有汇成功，汇款机需要先将我汇的钱再存进我的卡里，然后告诉我，没有汇成功，我再去处理这个没有汇成功的异常（换个银行或者换台机子）

异常的注意事项：

在子父类覆盖时：

1，子类抛出的异常必须是父类的异常或者异常的子类，或者子集

2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能throws

参阅例子：

老师用电脑上课

图形面积