思维导图：

异常处理.png

一、异常的分类

1. 编译时期异常

直接父类为 Exception 则为编译时期异常。

编译时期异常需要在编译阶段进行处理，否则编译器报错，如果不处理，则无法执行代码，如下：

public class XKException {static void Test() {ExceptionTest();// 报错：Unhandled exception: java.lang.ClassNotFoundException}static void ExceptionTest () throws ClassNotFoundException {ClassNotFoundException exception = new ClassNotFoundException("出事啦！！！");throw  exception;}
}

结果：

编译时期异常

2. 运行时期异常

直接父类为 RuntimeException 时，表示运行时期异常；

运行时异常在编译时期不处理，但是在运行时则会 crash：

运行时异常

RuntimeException 的父类也是 Exception

二、异常处理

异常必须进行处理，否则在编译时期就会报错，或者在运行时 crash，一般有几种方式：

1. 上抛；
2. try catch；

完整的处理流程如下：

异常处理流程

1. 上抛

处理方式：在函数声明后面加上 @throws xxxException；

原理：此种处理方式会将异常按照函数的调用者层级向上抛，如果抛到 main 函数还没有处理，最终会抛给 JVM，JVM 会终止程序；

public class XKExceptionTest {// main函数继续上报Exception给JVMpublic static void main(String[] args) throws ClassNotFoundException {XKExceptionTest.Test();}// 上报Exceptionstatic void Test() throws ClassNotFoundException {ClassNotFoundException exception = new ClassNotFoundException();throw exception;}
}

因为 main 函数依旧没有处理 exception，所以最终会抛给 JVM，在运行时 crash：

JVM终止程序

但是有个注意点：

• 子类不能比父类抛出更多的异常；

例子：

sleep方法

上述代码会报错：

子类不能比父类抛出更多异常

如上代码，Runnable 接口中的 run 方法并没有抛出异常，子类实现 runnable 接口的 run 方法时，不能抛出异常；而 sleep 方法是有可能出现异常的：

sleep方法

因此，只能使用 try catch 进行捕捉；

2. try catch

处理方式：对于有 throws 的函数，在 try 语句中进行函数调用并使用 catch 捕捉异常并处理；

上述代码可以写成：

try catch

3. try catch 的几个特点

1. try 中语句检测到异常时，那一行代码之后的代码不会运行，但是不影响 try catch 整体之后的代码运行；
2. 如果 try 中的代码存在多个异常需要处理，那么都需要在 catch 中处理；
3. 多个异常的处理有两种方案，一个是或符号，一个是多个 catch；
4. catch 中的错误类型可以是多态形式，但是要确保所有的类型都被处理到；

示例：

多exception处理

另外，如果对异常的处理比较统一，可以在 catch 中使用 Exception 来拦截所有的异常情况，不需要或符号或者多个 catch 了：

拦截所有exception

4. finally

不管怎样都会执行，其含义包括：

1. try 中代码没有报异常；
2. try 代码出现了异常；

作用：出错或者不出错都需要执行的操作，比如 I/O 流的关闭：

public class XKException {static void Test() {FileInputStream fileStream = null;try {fileStream = new FileInputStream("x//xxxx/xxx");} catch (FileNotFoundException e) {System.out.println("文件未找到");} finally {// 不管是否出错，I/O流都需要关闭if (fileStream != null) {try {// 可能会出现IOException异常，需要处理fileStream.close();} catch (IOException e) {e.printStackTrace();}}}}
}

即使 try 中 retrun 了，finally 中的代码也会执行：

try {System.out.println("xxx");return;
} finally {System.out.println("这里的代码仍然会执行");
}
System.out.println("这里的代码不会执行"); // 编译报错

其本质是走到 return 时会先去检测 finally 中是否有代码，如果有就先执行再 return；

退出 JVM 时 finally 不会执行：

try {System.out.println("try");System.exit(0);
} finally {System.out.println("退出JVM后finally中的代码不执行");
}

虽然 finally 中的代码在 return 之前执行，但是返回值不会被改变，因为 Java 中所有代码都需要遵循两条规则：

• 顺序执行
• return 一旦执行，方法必须立即结束；

例子：

static void Test() {int i = FinallyTest();System.out.println("方法的返回值为：" + i); //100
}static int FinallyTest() {int a = 100;try {return a;} finally {a++;System.out.println("finally中的a为：" + a); //101}
}

反编译之后的结果：

int a = 100;
int j = a;
j++;
return j;

结果：

finally中的a为：101
方法的返回值为：100

这里和 OC 中的原理差不多，相当于 finally 中对变量进行了引用或者赋值。这也是为什么 finally 中可能出现内存泄漏的原因；

三、final、finally、finalize 对比

final

1. 关键字；
2. 修饰变量时存储在常量区，表示只能在初始化时赋值；
3. 修饰成员属性时，表示只能在构造函数中初始化，或者声明时初始化。此时视情况而定，最好加上 static，否则多个实例变量会占用多块内存；
4. final 修饰类时，该类不能被继承，比如系统类 String；
5. final 修饰方法是，子类无法重写该方法，但是不影响该方法重载；

finally

1. 和 try catch 一起使用；
2. finally 中的代码无论是否异常都会执行；
3. 如果 try 中有 return，finally 的代码在 return 之前执行，但是不影响返回值的结果，因为 finally 内部对使用到的变量进行了捕捉，非引用类型重新赋值一个新的变量，引用类型进行深拷贝，即重新复制了一个实例对象；
4. OC 中 finally 存在内存泄漏的风险；

对比 const 回顾：

1. 不改变生命周期；
2. 不改变作用域；
3. 只表示被修饰的部分不可变，且只修饰变量，其他关键字不会影响，比如 static、变量类型等；
4. 如果是非指针类型，则单纯的表示变量的值不可变；
5. 如果是指针类型，修饰 const * xxx 时表示变量所指向的对象不可变；
6. 如果是指针类型，修饰 * const xxx 时表示

四、自定义Exception

按照国际惯例，自定义的异常应该总是包含如下的构造函数：

1. 一个无参构造函数
2. 一个带有String参数的构造函数，并传递给父类的构造函数。
3. 一个带有String参数和Throwable参数，并都传递给父类构造函数
4. 一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

下面是IOException类的完整源代码，可以借鉴：

package java.io;public class IOException extends Exception {static final long serialVersionUID = 7818375828146090155L;public IOException() {super();}public IOException(String message) {super(message);}public IOException(String message, Throwable cause) {super(message, cause);}public IOException(Throwable cause) {super(cause);}