异常

概述

（1）程序在运行时出现的不正常情况
（2）问题也是现实生活中的一个具体的事物，也可以通过Java的类的形式进行描述，并封装成对象。异常将正常流程代码和问题处理代码相分离，方便了阅读
（3）对于严重的问题，Java通过Error类进行描述，一般不编写针对性的代码对其进行处理；对于非严重的问题，Java通过Exception类进行描述，可以使用针对性的处理方式进行处理，而Error类和Exception类都继承自Throwable类

异常的处理

class Demo
{
    int div(int a,int b)throws Exception //在功能上通过throws关键字声明该功能有可能会出现问题
    {
        return a/b;
    }
}
public class Test
{
    public static void main(String[] args) 
    {
        Demo d=new Demo();
        try
        {
            int c=d.div(4, 0);
            System.out.print(c);
        }
        catch(Exception e)
        {
            System.out.println("除数不能为0");
            e.printStackTrace(); //打印异常名称，信息，出现位置
        }
        System.out.println("over");
    }
}

在没有try..catch..机制时，jvm识别出异常，封装成AritchmeticException对象，抛给调用该功能的调用者即这里的d.div（4，0），但是主函数里没有处理这种异常情况的代码，所以jvm会调用默认的异常处理机制，导致程序停止。而使用try..catch..后，try语句检测到了AritchmeticException对象后将它抛给catch，catch通过Exception e接收到了这个new AritchmeticException（）异常对象，执行处理代码，之后再处理catch块后的代码，不会导致程序停止，增强了程序的健壮性

throws关键字声明抛出异常：
当前方法不知道如何处理这种类型的异常，该异常应该由上一级调用者处理
如果main方法也不知道如何处理这种类型的异常，也可以使用throws声明抛出异常，将该异常交给jvm处理

多异常

class Demo
{
    int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException 
    {
        int[] arr=new int[a];//可能出现数组越界异常
        System.out.println(arr[4]); 
        return a/b;
    }
}
public class Test 
{
    public static void main(String[] args) 
    {
        Demo d=new Demo();
        try
        {
         /* int c=d.div(4, 0); ①
            int c=d.div(5, 0); ②
            int c=d.div(4, 1); ③ */
            System.out.print(c);
        }
        catch(ArithmeticException e)
        {
            System.out.println("除数不能为0");
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("数组越界了");
        }
        System.out.println("over");
    }
}
/*①数组越界了   over
 ②0  除数不能为0  over
 ③数组越界了over */

注意：
1.声明异常时，建议声明更为具体的异常，这样可以处理的更具体
2.对方声明几个异常，就对应有几个catch块，不要定义多余的catch块
如果多个catch块中的异常出现继承关系，父类异常catch要放在最后面

自定义异常

因为项目中可能出现特有的问题，而这些异常并未被Java所描述并封装对象。所以对于这些特有的问题可以按照Java的对问题封装的思想，将特有的问题，进行自定义的异常封装
eg:自定义除法除数不能为负数

/* 注意 自定义异常要继承Exception或者RuntimeException：
     异常体系中的类和异常对象都要被抛出他们都具有可抛性，这个可抛性是Throwable这个体系中的独有特点
     只有这个体系中的类和对象才可以被throw和throws操作 
*/
class FushuException extends Exception
{
//定义异常信息，方便e.toString（）进行打印
//Exception类里有构造方法 Exception(String message) 构造带指定详细消息的新异常，所以可以直接在子类里调用
    private int value;
    FushuException(String msg,int value)
    {
        super(msg); 
        this.value=value;
    }
    public int getValue()
    {  //这里的value是自定义加上的
        return value;
    }
}
class Demo
{
    int div(int a,int b) throws FushuException
    {//当在函数内部出现了throw抛出异常对象，那么就必须给出对应的处理动作：要么在函数内部try catch 处理，要么在函数上声明，让调用者处理
        if(b<0)
            throw new FushuException("出现了除数为负数的情况",b);  //通过throw关键字，手动抛出自定义异常对象
        return a/b;
    }
}
public class Test 
{
    public static void main(String[] args) 
    {
        Demo d=new Demo();
        try
        {
            System.out.print(d.div(4, -1));
        }
        catch(FushuException e)
        {
            System.out.println(e.toString());  //打印异常名称和信息
            System.out.println("除数不能为负数");
            System.out.println("错误的除数是"+e.getValue());
        }
        System.out.println("over");
    }
}

throws和throw的区别：
1. throws使用在函数上；throw使用在函数内
2. throws后面跟的是异常类，可以跟多个，用逗号隔开；throw后面跟的是异常对象

Runtime异常体系：

Java的异常分为两大类：Checked异常和Runtime异常
所有的RuntimeException类及其子类的实例被称为Runtime异常(运行时异常)，否则是Checked异常（编译时被检测异常）
如果在函数内容抛出Runtime异常，函数上可以不用声明，编译可以通过
如果在函数上声明了Runtime异常，调用者可以不用进行处理，编译可以通过
当Runtime异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后对代码进行修正

自定义异常时，如果该异常的发生，无法继续进行运算，就让自定义异常继承RuntimeExcepition

Finally代码块

1. 定义一定执行的代码，通常用于关闭资源
2. finally只有一种情况不会执行，即执行到 System.exit(0)

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

1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类
2. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集
3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常
   如果子类方法发生了异常，就必须要进行try catch处理

总结：异常处理原则

1.处理方式有两种：try或者throws
2.调用到抛出异常的功能时，抛出几个，就处理几个，一个try对应多个catch
3.多个catch时，父类的catch放在最下面
4.catch内需要定义针对性的处理方式，不要简单的定义printStackTrace等，也不要不写
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出

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

如果该异常处理不了，但并不属于该功能相关的异常，可以将异常转换后，再抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道并处理，也可以将捕获异常处理后，转换新的异常:比如汇款时发生异常，要保证异常得到处理，钱汇成功，但也要让调用者知道

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