异常处理（try-catch）

错误的种类

一般来讲，程序出现错误的时候，大致情况有三种：

1. 语法错误
2. 运行时错误，指的是各程序运行的时候，出现的一些没有想到的问题，比如除数为0，比如数组下标越界等等
3. 逻辑错误，运行结果和与其结果不一致，俗称bug

?Java中的异常处理机制主要用于处理运行时错误

异常的定义

? 运行时发生的错误，叫做异常，处理这些异常的代码叫做异常处理，一旦发生异常，程序将会中止在异常发生的地方，之后的代码都不会被运行

public static void main(String[] args) {
    // 这句输出会抛出异常
    System.out.println(1/0);
    // 这句输出就不会被执行
    System.out.println("tmp_text");
}

异常的处理方式

? Java使用面向对象的方法来处理异常，在方法的执行过程中，如果出现了异常，该方法就会自动创建一个代表该异常的一个对象，将其交给运行时的系统，运行时系统自动查找对应的代码来处理这个异常，在这个过程中，生成异常，并且将其交给运行时系统的过程叫做抛出异常（throw），运行时系统，找到能处理该异常的对象的过程叫做捕获异常（catch）

异常类（Throwable类）

? 根据javac对异常处理的要求，把异常分为两类

1. 非检查异常-运行时异常（RunTImeException）：程序本身问题导致的异常，运行时异常并不一定需要做异常处理，不做异常处理，代码也可以通过编译
2. 检查时异常（ChackedException）：检查时异常，可能产生检查时异常的代码，不管是否产生了异常，都必须进行异常处理，负责无法通过编译，检查时异常大部分情况下和开发者无关，只和代码之外的环境有关

处理异常的方法（Try--Catch）

? Try 负责存放可能会产生异常的代码，catch 负责捕捉异常

? 异常处理在很多的时候，只能保证哪怕发生了异常，代码整体也可以正常的运行，但是不能解决异常的问题，还是需要有开发者自己修改代码，从根源上解决问题

// 运行时异常
// 除数为0异常是个典型的运行时异常，运行时异常并不一定需要做异常处理，不做异常处理，代码也可以通过编译
public void test(){
    try{
        // 会产生除数为0的异常
        System.out.println(1/0);
    }catch (Exception e){
        // 打印异常相关的堆栈信息，但是并不是一定要写
        e.printStackTrace();
    }
    System.out.println("异常被处理了之后，程序依旧可以往下运行！");
}

// 检查时异常
// 不管代码是否发生异常，都需要进行异常处理，负责无法通过编译，检查时异常大部分情况下和开发者无关，只和代码之外的环境有关
public void test(){
    try {
        // 检查时异常，必须使用try——catch进行处理
        Class.forName("com.test");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.out.println("异常被处理了之后，程序依旧可以往下运行！");
}

// 如果有多条可能发生异常的语句，最好每一个语句单独处理，多条语句同时进行异常处理，会出现代码少运行的问题

finally关键字

? 确保在异常发生的时候，所有的收尾工作可以正常的完成，无论是否发生异常，finally代码块中的语句都会执行

?如果在catch代码块中出现了return，那么也必须先执行finally中的代码之后，再return退出

// 发生异常时： try -> catch -> finally
// 没有发生异常时：try -> finally
public void test(int tmp) {
    try {
        System.out.println("test -> try()");
        tmp = 1 / tmp;
    } catch (ArithmeticException e) {
        System.out.println("test -> catch()");
    } finally {
        System.out.println("test -> finally()");
    }
}
// tmp = 1:
// 	test -> try()
// 	test -> finally()
// tmp = 0:
// 	test -> try()
// 	test -> catch()
// 	test -> finally()

throw关键字

? 可以借助throw关键字，主动抛出一个指定类型的异常

public void test(){
    try {
        // 主动抛出一个空指针异常
        throw new NullPointerException();
    }catch (NullPointerException e){
        System.out.println("捕获了异常");
    }
}

throws关键字

? 如果某个方法不想处理异常，可以使用throws向上抛出异常，让上层的调用者进行异常处理

public class Test04 {
    // test01负责抛出异常
    public void test01(){
        throw new NullPointerException();
    }
    // test02运行test01时触发异常，但是并没有处理，使用throws向上抛出了此异常
    public void test02() throws NullPointerException{
        test01();
    }
    // test03处理test02向上抛出的异常
    public void test03(){
        try {
            test02();
        }catch (NullPointerException e){
            System.out.println("捕获了异常");
        }
    }
}

throw 和throws 的区别

1. throw时语句抛出一个异常，throws是方法抛出一个异常
2. throws可以单独使用，但是throw后面必须跟一个明确的异常对象
3. throws出现方法的头，throw出现再方法体
4. throws表现的是出现异常的一种可能性，并不代表以后一定会出现异常，但是throw一定会抛出异常
5. 两种都是异常处理的消极方式，最终还是需要使用try_catch进行异常处理

常见异常类型

1. RuntimeException：所有运行时异常的父类
2. ArithmeticException：算数错误异常
3. IllegalAccessError：方法接收到非法参数异常
4. ArrayIndexOutOfBoundsException：数组下标越界异常
5. NullPointerException：空指针异常
6. ClassNotFoundException：找不到类异常
7. IOException：IO流异常
8. FileNotFoundException：找不到文件异常
9. EOFException：数据流相关异常