异常

概念

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

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

异常指的并不是语法错误，语法错了，编译不会通过，不会产生字节码文件，根本不能运行。

异常体系

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

Throwable体系：

• Error:严重错误，无法通过处理的错误，只能事先避免。
• Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

异常分类

java.lang.Thorwable:类是java语言所有错误或异常的超类。

1. Exception:编译期异常，进行编译（写代码）java程序出现的问题。
2. RuntimeException:运行期异常，java程序运行过程中出现的问题。

• 异常相当于程序出了点小毛病，把异常处理掉，程序可以继续执行。

1. Error：错误

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

处理异常的两种方式

1. 选中代码中出现红线的位置（异常位置），alt+回车，选择Add exception to method signature，这种处理方式会让我们的代码运行，然后把异常显示在控制台。
2. 选中代码中出现红线的位置（异常位置），alt+回车，选择Surround with try/catch，这种处理方式也会将异常显示在控制台，但是跟上一个不同，这种处理方式会在跳过异常位置之后，继续执行后方代码。

JVM检测出异常后会做的事情

1. JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了一场产生的（内容、原因、位置）
2. 在getElement方法中，没有异常的处理逻辑（try...catch），那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常。
3. main方法接受到了这个异常对象，main方法也没有异常的处理逻辑，继续把对象抛出给main方法的调用者jvm处理。
4. JVM接受到了这个异常对象，做了两件事。第一是把异常对象（内容、原因、位置）以红色的字体打印在控制台。第二是终止当前正在执行的java程序，也就是中断处理。

Throw关键字

作用：
可以使用throw关键字在指定的方法中抛出指定的异常。

使用格式：
throw new xxxException("异常产生的原因");

注意：

1. throw关键字必须写在方法的内部。
2. throw关键字后便new的对象必须是Exception或者Exception的子类对象。
3. throw关键字抛出指定的一场对象，我们就必须处理这个异常对象。（1.throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理【打印异常对象，中断程序】；2.throw关键字后边创建的是编译一场【写代码的时候报错】，我们就必须处理这个异常，要么throws，要么try...catch）

以后（工作中）我们首先必须对方法传递过来的参数进行合法性校验，如果参数不合法，那么我们就必须使用抛出一场的方式，告知方法的调用者，传递的参数有问题。

Objects非空判断

Objects类中的静态方法：
public static T requireNonNull(T obj):查看指定引用对象不是null。
源码：
public static T requireNonNull(T obj){
if(obj == null)
throw new NullPointerException();
return obj;
}

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

throws关键字：异常处理的第一种方式，交给别人处理。
作用：
当方法内部抛出一场对象的时候，那么我们就必须处理这个异常对象。
可以使用throws关键字处理异常对象，会把一场对象声明抛出给方法的调用者处理(自己不处理，给别人处理)，最终交给JVM处理-->中断处理。

使用格式：
在方法声明时使用
修饰符 返回值类型 方法名（参数列表） throws{
throw new AAAException("产生原因");
throw new BBBException("产生原因");
}

注意事项：

1. throws关键字必须写在方法声明处。
2. throws关键字后边声明的异常必须是Exception或者是Exception的子类。
3. 方法内部如果抛出了多个异常对象，那么throws后便必须也声明多个异常。（如果抛出的多个一场对象有子父类关系，那么直接声明父类异常即可）
4. 调用了一个声明，抛出异常的方法，那么我们就必须处理声明的异常。（要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM；要么try...catch自己处理异常）

try_catch_异常处理的第二钟方式，自己处理异常

格式：
try{
可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
异常的处理逻辑，异常对象之后，怎么处理异常
}
···
catch(异常类名 变量名)｛

｝

注意：

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

finally代码块

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

}finally{
无论是否出现异常都会执行
}

注意：

1. finally不能单独使用，必须和try一起使用。
2. finally一般用于资源释放（资源回收）,无论程序是否出现一场，最后都要资源释放

异常的注意事项

• 多个异常如何捕获处理
  1. 多个异常分别处理。（一个异常，一个try...catch）
  2. 多个异常一次捕获，多次处理。（多个异常，一个try，多个catch）
     注意事项：catch里面定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会报错。
  3. 多个异常一次捕获，一次处理。

如果finally里面有return语句，那么将会永远返回finally中的结果，应该尽量避免这种情况。

子父类的异常：

1. 如果父类抛出了多个异常;子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者抛不出异常。
2. 父类方法没有抛出一场，子类重写父类该方法时也不可抛出一场。此时子类产生该一场，只能捕获处理，不能声明抛出。
   注意：
   父类异常时什么样子，子类异常就什么样。