一、异常概念

异常就是指在程序执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

注意，异常指的并不是语法错误，否则，编译就不会通过，不会产生字节码文件，不能运行。

二、异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：
java.lang.Error和java.lang.Exception。

Throwable体系：

    Error：严重错误Error，无法通过处理的错误，只能实现避免，好比绝症

    Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理好的。好比于感冒

Throwable中的常用方法：

    public void printStackTrace():打印异常的详细信息
    包含了异常的类型，异常的原因，异常出现的位置，在开发和调试阶段，都得使用printStackTrace。

    public String getMessage():获取异常发生的原因
    提示给用户的时候，就提示错误原因

    public String toString():获取异常的类型和异常描述信息（不用）

三、编译期异常 VS 运行期异常
java.lang.Throwable:该类是Java语言中所有错误或异常的超类。
它有两个子类：

    Exception：编译期异常，进行编译（写代码的时候）时，java程序出现的问题
        Exception下面还有一个子类：
            RuntimeException：运行期异常，Java程序运行过程中出现的问题
            异常就相当于程序得了一个小毛病（好比感冒），把异常处理掉（好比吃点药），程序可以继续执行

    Error：错误
        错误就相当于程序得了一个无法治愈的毛病，必须修改源代码，程序才能继续执行

Exception：【编译期异常】，进行编译（写代码的时候）时，java程序出现的问题

第一种处理方式：throws ParseException，交给JVM处理
JVM会中断程序，然后将异常打印在终端
第二种处理方式：surround with try/catch
该方式有一个好处：可以将异常信息打印出来，但是后面的代码可以继续执行

RuntimeException：【运行期异常】，Java程序运行过程中出现的问题
使用try/catch来处理这个异常,使用try/catch时，【即使出现了异常，后面的代码也可以【继续执行】

try {
	//try中放的是可能会出现异常的代码
	
}catch (Exception e){
    //catch中放的是异常的处理逻辑

}

Error

必须修改源代码，才能改正Error错误
和异常不同，异常处理完之后可以继续执行

异常的产生过程解析：

    //在main方法中，调用方法arrayValueOfIndex
    int value = arrayValueOfIndex(array, 3);

    //在arrayValueOfIndex方法中
    int value = array[index];   此时index=3

    一、即访问了数组中的3索引，而数组是没有3索引的，这时候，JVM就会检测出程序会出现异常，JVM会做两件事：

        1.JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的内容、原因和位置
            new ArrayIndexOutOfBoundsException("3");

        2.在arrayValueOfIndex方法中，没有异常处理逻辑（try...catch），那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常

   二、main方法接收到了这个异常对象（new ArrayIndexOutOfBoundsException("3");），main方法中也没有异常处理逻辑，就会继续把对此昂抛出给main方法的调用者JVM处理。

   三、JVM接收到了这个异常对象（new ArrayIndexOutOfBoundsException("3");），做了两件事：

        1.把异常对象的内容、原因和位置以红色的字体打印在控制台

        2.JVM会终止当前正在执行的java程序——【中断处理】

throw关键字：

throws关键字：异常处理的第一种方式，交给别人处理

作用：
	当方法内部抛出异常对象的时候，我们就必须处理这个异常对象
	
    可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理），最终交给JVM处理——中断处理

使用格式：
    在方法声明时使用,抛出多少个，就声明多少个：
    修饰符 返回值类型 方法名(参数列表) throws AAAException, BBBException{  // 声明多个异常
        // 抛出多个异常
        throw new AAAException("产生原因");
        throw new BBBException("产生原因");
    }
注意事项：
    1.throw关键字必须写在方法的内部
    
    2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
    
    3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象，方法内部如果【抛出】了多个异常对象，那么throws关键字后面也必须【声明】多个异常，如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可。
    
    4.throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断处理）
      throw关键字后边创建的是【编译异常】，我们就必须处理这个异常，要么throws，要么try...catch

try…catch:

try...catch:异常处理的第二种方式，自己处理异常

格式：
    try{
        可能产生异常的代码
    }catch(定义一个异常的变量，用来接收try中抛出的异常对象){
        异常的处理逻辑，异常对象之后，怎么处理异常
        一般在工作中，会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){
    }

注意事项：
    1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
    2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的
      处理逻辑，继续执行try...catch之后的代码。
      如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，
      继续执行try...catch之后的代码。

finally代码块：

格式：
    try{
        可能产生异常的代码
    }catch(定义一个异常的变量，用来接收try中抛出的异常对象){
        异常的处理逻辑，异常对象之后，怎么处理异常
        一般在工作中，会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){
    }finally{
        无论是否出现异常，都会执行
    }

注意事项：
    1.finally不能单独使用，必须和try一起使用
    2.finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放（IO）

多个异常使用捕获该如何处理？

1.多个异常分别处理

2.多个异常一次捕获，多次处理
	一个try，多个catch，注意事项：
     	catch里面定义的异常变量，如果有子父类关系，那么子类的异常变量，必须写在上面，否则就会报错
        ArrayIndexOutOfBoundsException是IndexOutOfBoundsException的子类，所以ArrayIndexOutOfBoundsException 放在了上面。
        
        原因分析：
            try中可能会产生的异常对象：
                new ArrayIndexOutOfBoundsException("3");
                new IndexOutOfBoundsException("3");

            try中如果出现了异常对象，会把异常对象抛出给catch处理
            抛出的异常对象，会从上到下【依次赋值】给catch中定义的异常变量：
                ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException("3");
                IndexOutOfBoundsException e = new IndexOutOfBoundsException("3");
                这样是没有问题的。
            但是如果父类变量写在了子类变量上边，则会有问题：
                IndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException("3");  //多态写法
                IndexOutOfBoundsException e = new IndexOutOfBoundsException("3");
                也就是，不管是哪一个异常对象，都可以由父类异常变量接收，所以子类异常变量是没有被用到的，会报错

3.多个异常一次捕获，一次处理

4.如果finally有return语句，永远返回finally中的结果，避免该情况，即finally中不要写return语句。

子父类的异常：

1.如果父类抛出了多个异常，子类重写方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

2.父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。

注意：
    【父类异常是什么样，子类异常就是什么样】

Objects类中的静态方法:

public static <T> T requireNull(T obj):查看指定引用对象不是null。
源码：
    public static <T> T requireNonNull(T obj){
        if(obj == null)
            throw new NullPointerException();
        return obj;
    }

自定义异常类：

java提供的异常类，不够我们使用，需要自己定义一些异常类

格式：
    public class XxxException extends Exception/Runtime Exception{
        添加一个空参构造方法
        添加一个带异常信息的构造方法
    }
注意：
    1.自定义异常类一般都是以Exception结尾，说明该类是一个异常类
    2.自定义异常类，必须继承Exception或者RuntimeException
        继承Exception，那么自定义的异常类，就是一个编译期异常，如果方法内部抛出了编译器异常，就必须处理这个异常，要么throws，要么try...catch
        继承RuntimeException，那么自定义的异常类，就是一个运行期异常，无需处理，交给JVM处理——中断处理。

添加一个带有异常信息的构造方法：
    查看源码发现，所有的异常类都会有一个带异常信息的构造方法，方法内部会调用父类带异常信息的方法，让父类来处理这个异常信息,实际上调用的是父类的空参构造方法。