Java：Exception

异常：

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

异常的由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象的体现。

两种问题：

严重问题（Error）、非严重问题（Exception）。

Error和Exception具有一些共性内容。(都是Throwable的子类)

try
{
    需要被检测的代码
}
catch(异常类 变量)
{
    处理异常的代码；（处理方式）    
}

严重问题：

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

非严重问题：

Java通过Exception类进行描述。对Exception可以使用针对性的代码进行处理。

异常的处理：

try
{
    需要被检测的代码
}
catch(异常类 变量)
{
    处理异常的代码；（处理方式）    
}

异常的常见操作：

getMessage() :返回信息：异常原因

toString():反馈信息：异常类+异常原因

printStackTrace():反馈堆栈中的异常信息 异常类+异常原因+异常出现的位置，其实jvm默认的异常处理机制就是在调用printStackTrace方法

例如，除数是零

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);//捕获到异常对象 new AritchmeticException()
            System.out.println("x=" + x);
        }
        catch (Exception e)//把捕获到的异常给了catch: Exception e = new AritchmeticException();
        {
            System.out.println("除数是零！");
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();
        }

        System.out.println("Program Over!");
    }
}

      但我们在定义Class时就应该提示是否会出现异常，提醒调用该Class时是需要处理Exception。当调用者使用该Class时，必须捕获该类的异常进行处理或者抛出。

捕获：try-catch处理

class Demo
{
    int div(int a, int b)throws Exception//在功能上通过throws关键字声明了该功能在使用时有可能出现问题
    {
        ...
    }
}

class ExceptionDemo 
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();
        try
        {
            ...
        }
        catch (Exception e)
        {
            ...
        }
    }
}

抛出：调用该有标识异常的类的方法上通过throws抛出，不处理

class Demo
{
    int div(int a, int b)throws Exception//在功能上通过throws关键字声明了该功能在使用时有可能出现问题
    {
        ...
    }
}

class ExceptionDemo 
{
    public static void main(String[] args)throws Exception
    {
        ...
    }
}

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

例如上面的例子，可以把异常由Exception更改为ArithmeticExcption

·有多个异常时，可以针对性用多个catch处理。如果多个异常有继承关系，父类异常的catch放在最下面

建议进行catch处理时，catch中一定要定义具体的处理方式，不要简单的使用printStackTrace()等等

class Demo
{
    int div(int a, int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//抛出多个异常
    {

        int[] arr = new int[a];
        System.out.println(arr[5]);//可能出现异常的地方

        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 (ArithmeticException e)//处理异常
        {
            System.out.println("除数是零！");
            e.printStackTrace();
        }
        catch (ArrayIndexOutOfBoundsException e)//处理异常
        {
            System.out.println("数组角标异常！");
            e.printStackTrace();
        }

        System.out.println("Program Over!");
    }
}

自定义异常：

　　因为项目中会出现特有问题，而这些问题是Java未对其描述并封装成对象。所以对这些特有问题可以按照Java对问题的封装思想，对其封装。

　　当在函数内部出现了throw抛出异常对象，那么就必须要给出对应的处理。要么在内部try-catch，要么在函数上声明让调用者处理。 一般情况下，函数内出现异常，函数上需要声明。

如何自定义异常信息呢？
　　因为父类已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类，通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息了。

继承Exception的原因
　　异常体系都有一个特点：异常类和异常对象都被抛出。
　　他们都具有可抛性，是Throwable这个体系的独有特点。只有这个体系中的类和对象才可以被throws和throw操作。

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

/*
需求：在本程序中，不允许除数为负数。
因为该需求是特殊要求，所以要对这个问题进行自定义的描述；
*/
class DefinedException extends Exception
{
    private int value;

    DefinedException()
    {
        System.out.println("自定义异常的空参数的构造函数：除数不能为负数");
    }
    DefinedException(String msg)
    {
        super(msg);
    }
    DefinedException(String msg, int value)
    {
        super(msg);
        this.value = value;
    }

    public int getValue()
    {
        return value;
    }
}

class Demo
{
    int div(int a,int b)throws DefinedException
    {
        if (b<0)
        {
            //throw new DefinedException();
            //throw new DefinedException("除数不能为负数！");
            throw new DefinedException("除数不能为负数！",b);//手动通过throw抛出
        }
        return a/b;
    }
}
class DefinedExceptionDemo 
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,-1);
            System.out.println("a/b="+x);
        }
        catch (DefinedException e)
        {
            System.out.println("除数不能为负数！");
            System.out.println("错误的数是："+e.getValue());
            //d.printStackTrace();
        }

        System.out.println("Program Over!");
    }
    
}

 RuntimeException：

　　Exception中有一个特殊的子类异常RuntimeException 运行时异常。

　　RuntimeException或者其子类的异常，可以不用在函数上使用throws申明。如果在函数上申明了该异常，调用者可以不用处理就可以通过编译。不申明的原因：当程序运行时遇到该异常，导致下面的程序不能预期运行，希望停止运行后修正该程序。（比如如果一个函数只申明了一个异常，而在函数内抛出了三个异常，那么另外两个异常必然就是RuntimeException或者其子类）

　　自定义异常时，如果该异常发生后无法继续工作，就让该异常继承RuntimeException

异常分两种：
　　1，编译时被检测的异常
　　2，编译时不被检测的异常，但运行时异常。RuntimeException及其子类

finally:

　　finally中的代码是一定会执行的代码，一般存放必须要操作的内容比如释放与数据库的连接、关闭IO等等。

　　finally只有一种情况不会被执行到：finally前面有System.exit(0)

异常处理的三种各式：

1， try-catch

2， try-catch-finally

3,   try-fiinally

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

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

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

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

　　如果子类方法发生了异常，就必须要try处理，绝对不能抛。