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：

---

多异常的处理方式

1. 声明异常时，建议声明更为具体的异常，这样处理的可以更具体，
2. 对方声明几个异常，就 对应有几个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代表该异常没有被处理过，如果该异常时检测时异常，那么必须申明。

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

1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常，或者父类异常的子类，
2. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法抛出了异常吗，就必须要进行try处理，绝对不能抛。
4. 
   用一个代码练习来说明这段文字：

//异常之间的关系是：
//   |--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
    参阅例子：
    老师用电脑上课
    图形面积