文章目录
- 一、前言
- 二、异常概述及异常体系结构
- 1.概述
- 2.异常体系结构
- 三、异常处理方式（两种）
- 1.方式一：try-catch-finally
- 2.方式二：throws
- 四、如何选择处理异常方式
- 五、手动抛出异常(throw)
- 六、自定义异常类
- 七、异常处理总结
一、前言
这篇技术博客是我复习尚硅谷JavaSE教程做的笔记总结，方便大家的学习同时也方便自己。
二、异常概述及异常体系结构
1.概述
我们在做程序开发时候，都想着把代码写的完美无瑕（不大可能），但是真实情况是在系统运行代码时，仍然会遇到一些问题，不能靠代码避免，比如：
- 客户输入的数据格式
- 读取文件是否存在
- 网络是否始终保持通畅
我们把这类问题，归结为异常！
异常概念：在Java语言中，将程序执行中发生的不正常情况称为异常（异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行）
Java中异常分为两类：
- Error：java虚拟机无法解决的严重问题（JVM系统内部错误、资源耗尽），一般没办法编写针对性代码进行处理（处理不了）
public class ErrorTest {
public static void main(String[] args) {
//1.栈溢出java.lang.StackOverflowError
main(args);
//2.堆溢出：java.lang.OutOfMemoryError
Integer[] arr = new Integer[1024 * 1024 * 1024];
}
}- Exception：因编程错误或偶尔的外在因素导致的一般性问题，可以使用针对性的代码进行处理（空指针访问，试图读取不存在的文件，网络连接中断，数组角标越界等）
注意：我们平常将Error和Exception都称作广义上的异常，但是由于我们不处理Error，所以我们平时在开发中提到的异常一般指的是Exception，我们说的异常处理指的就是狭义上的异常：Exception，所以此博客主要讲解的异常处理针对的是Exception
2.异常体系结构
捕获错误最理想的是编译期间，但有的错误只在运行期间发生，比如：除数为0、数组下标越界等
Exception分类：编译时异常（需要处理）、运行时异常（一般不处理）
体系结构图如下：
异常的顶级父类是 java.lang.Throwable，其下有两个子类：java.lang.Error 与 java.lang.Exception，平常所说的异常指java.lang.Exception 。
三、异常处理方式（两种）
Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。其实异常处理并非真正意义上将异常代码改正，修改代码操作还是需要开发人员自己去做！
异常的处理：抓抛模型
过程一（抛）：程序在正常执行过程中，一旦出现异常，就会在异常代码出生成一个对应异常类的对象，并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行。
过程二（抓）：可以理解为异常处理的方式：①try-catch-finally ②throws
关于异常对象的产生：
- 系统自动生成的异常对象
- 手动生成一个异常对象，并抛出（throw）
1.方式一：try-catch-finally
使用格式：
try{
...... //可能产生异常的代码
}
catch(ExceptionName1 e){
...... //当产生ExceptionName1型异常时的处置措施
}
catch(ExceptionName2 e){
...... //当产生ExceptionName2型异常时的处置措施
}
......
finally{
...... //无论是否发生异常，都无条件执行的语句
}
注意：finally为可选结构，是否使用取决于自己代码展示与说明：
/**
* 说明：
* 1.finally是可选的
* 2.使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象
* 根据此对象的类型，去catch中进行匹配
* 3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理，一旦处理完成就跳出
* 当前的try-catch结构（在没写finally情况下），继续执行其后的代码
* 4.catch中的异常类型如果没有子父类关系，则先声明谁都无所谓
* catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则报错
* 5.常用的异常对象处理的方式：①String getMessage() ②printStackTrace()
* 6.在try中声明的变量，在出了try结构后，不能再被调用
*/
public class ExceptionTest {
public static void main(String[] args) {
String str = "123";
str = "abc";
int num = 0;
try {
num = Integer.parseInt(str); //可能出现异常的代码
System.out.println("hello------1");
}catch (NullPointerException e){
System.out.println("出现空指针异常了，不要急");
}catch (NumberFormatException e){
//System.out.println("出现数值转换异常了，不要急");
//System.out.println(e.getMessage());
e.printStackTrace();
}catch (Exception e){
System.out.println("出现异常了，不要急");
}
System.out.println(num);
System.out.println("hello------2");
}
}上述代码中只使用了try-catch结构，并没有使用finally，接下来我们学习一下finally的使用细节：
- finally中声明的是一定会被执行的代码，即使catch中有出现异常，
try中有return语句，catch中有return语句等情况 - 像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，
我们需要自己手动进行资源释放。此时资源释放需要声明在finally中。
为了防止释放之前的代码有异常，导致资源不被释放， 所以放在finally中 - try-catch-finally可以嵌套使用
//不论是catch中有异常，还是catch中有return，我们的finally代码块一定会执行！
public class FinallyTest {
public static void main(String[] args) {
try {
int a = 10;
int b = 0;
System.out.println(a / b);
}catch (ArithmeticException e){
//e.printStackTrace();
int[] arr = new int[10];
System.out.println(arr[10]); //回报数组越界异常，但是没有处理
}catch (Exception e){
e.printStackTrace();
}finally {
System.out.println("就算你报异常，我也一定要执行！");
}
}
}我们在开发过程中对于运行时异常不用try-catch处理
也无法真正意义上解决，我们得去改代码。所以———运行时异常，不用try-catch
但是对于编译时异常需要对它try-catch，否则连编译期都过不去，更别说运行了！
编译过去了，如果运行正确就ok。如果运行出错，就是将异常延迟到运行期出现！
相当于我们使用try-catch结构将编译时异常变成运行时异常！体会1：使用try-catch-finally处理编译时异常，使得程序在编译就不在报错但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常延迟到运行时出现。
体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally，针对于编译时异常一定要考虑异常的处理（进行代码修改）！
2.方式二：throws
该方式写在方法的声明处，指明此方法执行时可能会抛出的异常类型，一旦当方法体执行时出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时就会被抛出。异常代码后续的代码不再执行！
代码演示：
public class ExceptionTest2{
public static void main(String[] args){
//如果抛给main方法，就需要try-catch处理了！
//不能再向上抛出了
try {
method2();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void method2() throws IOException{
method1();
}
public static void method1() throws IOException {
File file = new File("hello.txt"); //文件找不到，会报异常
FileInputStream fis = new FileInputStream(file);
int data = fis.read();//异常
while (data != -1){
System.out.println((char)data);
data = fis.read(); //异常
}
fis.close();//异常
}
}体会：两种异常处理方式的区别？
- try-catch-finally真正的将异常处理（并不是修改代码修正异常）
- throws方式（甩锅）只是将异常抛给方法的调用者，并没有真正将异常处理掉！
注意：子类重写的方法抛出的异常类型不大于（<=）父类被重写方法抛出的异常类型
四、如何选择处理异常方式
我们在开发中处理异常以该选择这两种方式中的哪一种呢？
- 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能够使用throws（原因看上述注意），意味着子类重写的方法中有异常，就必须使用try-catch-finally方式处理！
- 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。建议这几个方法使用throws方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理
二次理解：我们现在的两种异常处理方式，指的是代码执行之前可能会出现问题，我们提前做一个预案，万一出现问题了我们该怎么办！比如：弹出一个提示框。当然我们同时要明白：异常处理并不是真正意义上讲异常解决！异常处理机制不会帮助我们修正代码，还是需要我们自己处理修改异常代码！
五、手动抛出异常(throw)
关于异常对象的产生：
- 系统自动生成的异常对象
- 手动生成异常对象并抛出（throw）
代码展示：
public class StudentTest {
public static void main(String[] args) {
try {
Student s = new Student();
//数据非法，需要处理异常对象
//调用此方法进入到catch代码块中
s.regist(-1001);
} catch (Exception e) {
//控制台输出：您输入的数据非法
System.out.println(e.getMessage());
}
}
}
class Student{
private int id;
public void regist(int id) throws Exception {
if (id > 0){
this.id = id;
}else {
//手动抛出异常对象
throw new Exception("您输入的数据非法！");
}
}
}六、自定义异常类
我们上述见到的异常都是Java提供好的（官方的），我们当然也可以自己去自定义异常：
如何自定义异常类？
- 1.自定义类继承于现有的异常类结构：RuntimeException、Exception
- 2.提供全局常量：serialVersionUID 序列版本号，用于标识类
- 3.提供重载的构造器
代码展示：
//自定义异常类
public class MyException extends Exception{
static final long serialVersionUID = -7034897190745766939L;
public MyException(String msg) {
super(msg);
}
}
//学生类
class Student{
private int id;
public void regist(int id){
if (id > 0){
this.id = id;
}else {
throw new MyException("不能输入负数");
}
}
}
//测试类
class Test{
public static void main(String[] args) {
try {
Student s = new Student();
s.regist(-1001);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}七、异常处理总结
5个关键字几乎就能涵盖异常处理的所有内容了！
面试题：throw和throws区别？
- throw表示抛出一个异常对象，生成异常对象的过程。声明在方法体内
- throws属于异常处理的一种方式，声明在方法的声明处
