【JavaSE】异常处理机制

🎉🎉🎉点进来你就是我的人了
博主主页：🙈🙈🙈戳一戳,欢迎大佬指点!

欢迎志同道合的朋友一起加油喔🤺🤺🤺

---

目录

前言

 1.什么是异常

 2.异常的分类​编辑

2.1运行时异常

2.2编译时异常

3.异常的处理

3.1异常的抛出(throw)

3.2异常的捕捉        

(1)throws异常声明

(2)捕获异常并处理(try-catch)

(3)catch中如何处理异常

(4)try-catch的使用细节

(4)finaly

4.自定义异常类

---

---

前言

我们都知道在日常开发中，尽管努力地将代码写的尽善尽美，但在程序运行过程中，难免会出现一些奇奇怪怪的问题。有时通过代码很难去控制，比如：数据格式不对、网络不通畅、内存报警等。这就是Java的异常!

---

 1.什么是异常

在Java中，将程序执行过程中发生的不正常行为称为异常。

 2.异常的分类

（1）Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception

          而 Error 和 Exception 两子类分别表示错误和异常。

（2）Exception是异常，表示程序运行的时候，程序本身可以捕获并可以处理的错误。     

（3）Error是错误，表示运行应用程序中出现了严重错误，都是通过Error抛出的，一般程序无法处理(程序员不需要关注)；堆栈溢出是这种错误的一例。

异常可能在编译时发生，也有可能在程序运行时发生，根据发生时机不同，可以分为：

2.1运行时异常

运行时异常都是 RuntimeException 类及其子类异常,这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。通常这些异常一般由程序逻辑错误引起，程序应该从逻辑角度尽可能避免这类异常的发生。

（1）NullPointerException（空指针异常）

（2）ClassCastException（类型转换异常）

（3）ArithmeticException（算术异常）——除数为0的算术异常

（4）IllegalArgumentException（非法的参数异常）

NubmerFormatException（数字格式化异常）

（5）IllegalStateException（非法状态异常）

（6）IndexOutOfBoundsException（下标越界异常）

ArrayIndexOutOfBoundsException（数组下标越界异常）

StringIndexOutOfBoundsException（字符串下标越界异常）

（7）NoSuchElementException（没有这样的元素异常）

InputMisMatchException（输入类型不匹配异常）

2.2编译时异常

编译时异常是指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。

（1）IOException（输入\输出异常）

        FileNotFoundException（文件未找到异常）

        EOFException（EOF异常）

        MalformedURLException（格式错误的 URL 异常）

        UnknownHostException（未知主机异常）

（2）SQLException（SQL异常）

（3）CloneNotSupportedException（不支持克隆异常）

（4）ReflectiveOperationException（反射操作异常）

        ClassNotFoundException（类未找到异常）

---

3.异常的处理

异常处理主要的5个关键字：try、catch、final、throw、throws。

try:执行可能产生异常的代码；

catch：捕获异常；

finally:无论是否发生异常，代码总被执行；

抛出异常：

throw:异常生成阶段，手动抛出异常对象；

声明异常：

throws声明方法可能要抛出的各种异常类

语法格式：
try{
// 将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
// 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类
时，就会被捕获到
// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
}[catch(异常类型 e){
// 对异常进行处理
}finally{
// 此处代码一定会被执行到
}]
// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行
注意：
1. []中表示可选项，可以添加，也可以不用添加
2. try中的代码可能会抛出异常，也可能不会

3.1异常的抛出(throw)

在编写程序时，如果程序中出现错误，这就需要将错误的信息通知给调用者

这里就可以借助关键字throw，抛出一个指定的异常对象，将错误信息告知给调用者。

比如写一个运行时异常:

public class Demo {
    public static void func(int a) {
        if(a == 0) {
            //抛出的是一个指定的异常，最多的使用方式是，抛出一个自定义的异常
            throw new RuntimeException("a==0");
        }
    }
    public static void main(String[] args) {
        func(0);
    }
}

运行结果:

（1）throw必须写在方法体内部

（2）如果抛出的是编译时异常，用户就必须要处理，否则无法通过编译

（3）如果抛出的运行时异常，则可以不用处理，直接交给JVM来处理

（4）异常一旦抛出，其后的代码就不会执行

3.2异常的捕捉        

(1)throws异常声明

 throws处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，

此时就可以借助throws将异常抛给方法的调用者来处理。

格式：

修饰符 返回值类型 方法名(参数列表) throws 异常类型 {

}

注意:

1.如果说方法内部抛出了多个异常，throws之后就必须跟多个异常类型，用逗号进行分隔

2.如果抛出多个异常类型有父子关系，直接声明父类异常

3.调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

(2)捕获异常并处理(try-catch)

当程序抛出异常的时候，程序员可以通过try-each处理异常,如果不处理异常，那就会交给JVM处理，JVM处理就会把程序立即终止,并且try-each 捕获的异常必须是对应抛出的异常，如果不是对应异常，也会让JVM进行处理

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }
        System.out.println("其他！");
    }

注意:

如果try抛出多个异常，就必须用多个catch进行捕获

这里注意，用多个catch进行捕获，不是同时进行捕获的，因为不可能同时抛不同的异常

如果捕捉的异常之间具有父子关系，必须子类异常在前，父类异常在后，不然会报错  

(3)catch中如何处理异常

第一种处理：什么都不写，什么都不做

第二种处理：输出自定义异常信息

        System.out.println("对不起，你的代码有问题！");

第三种处理：打印异常信息：
            (1)调用toString方法，显示异常的类名（全限定路径）
            System.out.println(ex);
            System.out.println(ex.toString());
            (2)显示异常描述信息对应的字符串，如果没有就显示null
            System.out.println(ex.getMessage());
            (3)显示异常的堆栈信息：将异常信息捕获以后，在控制台将异常的效果给我们展示出来，方便我们查看异常
                ex.printStackTrace();
            第四种处理：抛出异常：
                throw ex;

public class Test {
    public static void main(String[] args) {
        //实现一个功能：键盘录入两个数，求商：
        try{
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第一个数：");
            int num1 = sc.nextInt();
            System.out.println("请录入第二个数：");
            int num2 = sc.nextInt();
            System.out.println("商："+num1/num2);
        }catch(Exception ex){
            //第一种处理：什么都不写，什么都不做
            //第二种处理：输出自定义异常信息
            //System.out.println("对不起，你的代码有问题！");
            //第三种处理：打印异常信息：
            /*(1)调用toString方法，显示异常的类名（全限定路径）*/
            /*System.out.println(ex);
            System.out.println(ex.toString());*/
            /*(2)显示异常描述信息对应的字符串，如果没有就显示null
            System.out.println(ex.getMessage());*/
            /*(3)显示异常的堆栈信息：将异常信息捕获以后，在控制台将异常的效果给我们展示出来，方便我们查看异常*/
           /* ex.printStackTrace();*/
            //第四种处理：抛出异常：
            throw ex;
        }
        System.out.println("----其它代码逻辑!");
    }
}

(4)try-catch的使用细节

（1）try中没有异常，catch中代码不执行。
（2）try中有异常，catch进行捕获：
        如果catch中异常类型和你出的异常类型匹配的话：走catch中的代码--》进行捕获
        如果catch中异常类型和你出的异常类型不匹配的话：不走catch中的代码--》没有捕获成功，程序相当于遇到异常了，中断了，后续代码不执行

（3）try中如果出现异常，然后用catch捕获成功的话，那么try中后续的代码是不会执行的。
（4）如果catch捕获异常成功，那么try-catch后面的代码该执行还是执行没有影响。

总结

1.在什么情况下，try-catch后面的代码不执行？
（1）throw抛出异常的情况
（2）catch中没有正常的进行异常捕获
（3）在try中遇到return

2.怎么样才可以将 try-catch后面的代码  必须执行？
只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行。

(4)finaly

在写程序时,有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

运行结果:
捕获到了一个空指针异常！
进行资源关闭！
其它代码逻辑！

如果将资源写在try中会自动帮助，关掉资源的

    public static void main(String[] args) {
        //将资源写到了try中    
        try (Scanner scanner = new Scanner(System.in)) {   
            int[] array = {1, 2, 3};
            System.out.println(array.length);
        } catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        } catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        } finally {
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

finally不要定义返回值，如果定义了返回值会先于try得返回

public class Test1 {
    public static void main(String[] args) {

        int i = printArr();

        System.out.println(i);

    }

    public static int printArr() {
        //定义一个数组
        String[] strings = {"张三", "李四", "王五",};

        try {
            //打印数组（给数组长度加1使数组打印越界）
            for (int i = 0; i < strings.length + 1; i++) {
                System.out.println(strings[i]);
            }
            //try返回得是1
            return 1;
            //捕获数据越界异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数据越界了");
            //空指针异常
        } finally {
            System.out.println("finally被打印了");
            //finally返回得是-1
            return -1;
        }

    }
}

输出结果:
张三
李四
王五
数据越界了
finally被打印了
-1

 System.exit(0); 只有这个可以治finally。

public class Demo {
        public static void main(String[] args) {
            try {
                System.out.println("我是try里面的语句");
                // 退出JVM
                System.exit(0); // 退出JVM之后，finally语句中的代码就不执行了！
            } finally {
                System.out.println("我是finally里面的语句");
            }
        }
}

运行结果:我是try里面的语句

 总结:finally语句一定会执行,且finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行 finally). 但是如果finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return.
一般我们不建议在 finally 中写 return (被编译器当做一个警告).

---

4.自定义异常类

虽然java中有很多异常类，但是在实际开发中所遇到的一些异常，不能完全表示，

所以这就需要我们自定义异常类

自定义异常步骤

1. 第一步：编写一个类继承 Exception 或者 RuntimeException.
2. 第二步：提供两个 构造方法，一个无参数的，一个带有String参数的。

代码演示如下:

//栈操作异常：自定义异常！
public class StackOperationException extends Exception{ // 编译时异常！
    public MyStackOperationException(){

    }

    public MyStackOperationException(String s){
        super(s);
    }
}

注意:重写之后的方法不能比重写之前的方法抛出更多的异常，可以更少。

自定义异常默认会继承 Exception 或者 RuntimeException

继承于 Exception 的异常默认是受查异常,使用的时候无需额外处理

继承于 RuntimeException 的异常默认是非受查异常,使用的时候需要try-catch捕获或者throws向上抛!