【一步一步了解Java系列】：认识异常类

看到这句话的时候证明：此刻你我都在努力
加油陌生人


个人主页：Gu Gu Study
专栏：一步一步了解Java

喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。
作者：小闭

---

异常类的概念及其层次结构

Java中存在异常类，那么何为异常类呢？那么我们必须先了解一下它的概念：Java异常处理是Java语言中非常重要的一部分，它允许程序在遇到错误时能够优雅地处理问题而不是直接崩溃。Java异常类主要分为两大类：检查型异常（Checked Exceptions）和非检查型异常（Unchecked Exceptions）。

1. 检查型异常/编译时异常（Checked Exceptions）：
   • 这些异常通常是由于编程错误导致的，比如FileNotFoundException或SQLException。
   • 它们必须在方法签名中声明抛出，或者在方法内部被处理（通常是通过try-catch块）。
   • 在运行前编译器就已经报出警告了：
   • 
2. 非检查型异常/运行时异常（Unchecked Exceptions）：
   • 这些异常通常是由于运行时错误导致的，比如NullPointerException或ArithmeticException。
   • 它们不需要在方法签名中声明，也不强制要求必须被捕获处理。
   • 如图在运行前编译器是不会提示错误的：

Java中的异常就像我们生活中人生病一样，我们的程序也会生病，我们可以把计算机的病就叫做“异常”。

---

那么下面就给大家解析一下其层次结构：
Java异常类的层次结构从__java.lang__包中的__Throwable__类开始，它有两个主要的子类：Exception__和__Error。

• Throwable：
  • Java异常类的根类。
  • 有两个重要的子类：Exception和Error。
• Exception：
  • 表示程序本身可以处理的异常情况。
  • 进一步分为IOException、SQLException等。
• RuntimeException：
  • Exception的一个子类，表示在Java程序运行时发生的异常。
  • 包括NullPointerException、IndexOutOfBoundsException等。
• Error：
  • 表示JVM无法处理的错误，比如OutOfMemoryError或StackOverflowError。
  • 通常不需要程序去捕获这些错误

---

有关处理异常的关键词

在Java中处理异常我们有这么几个常用的关键词 ：throw、try、catch、finally、throws。

1. ** throw 抛出异常 **

如下是一个简单的异常抛出，我们在一个方法中要执行一条语句时，如果其可能会发生异常，如：null，分母为0，数组访问越界，我们都可以自己抛出异常，如下为一个空指针异常

package demo1;

public class Test {

    public static void testExceptinon(int[] arr){
        if(arr==null){
        throw new ArithmeticException();
    }
    }


    public static void main(String[] args) {
        int[] arr=null;
        testExceptinon(arr);
    }

}

所谓抛出异常其实就是抛出一个Exception或Exception的子类。
注意事项：

抛出异常类其必须是Exception或Exception的子类。
抛出异常必须在方法内部
如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
** 如果抛出的是编译时异常，用户必须处理，否则无法通过编译**
** 异常一旦抛出，其后的代码就不会执**

---

2. 异常声明throws

throws一个用来声明异常的关键词，是用在方法上的，具体格式为
** 修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2…{ } **
注意throws只是起到警示作用，就是给程序员知道用这个方法可能会抛出异常。不会解决异常。

public class Test {

    public static final void test1 ()throws RuntimeException{
        int a=10;
        int c=0;
        System.out.println(a/c);

    }



}

3. ** try-catch捕获并处理 **

解决异常还得用到try-catch语句，这是我们常用处理异常的关键词，当然还有finally关键词，稍后我也会提到。

import com.sun.security.jgss.GSSUtil;

public class Test {

    public static final void test1 ()throws ArithmeticException{
        int a=10;
        int c=0;
        System.out.println(a/c);

    }

    public static void main(String[] args) {

        int q=10;
        int p=100;
        String s="hello world";
        System.out.println(q+p);
        try{
            test1();              //try的花括号内是放入可能会抛出异常的语句
                                  //如果里面的语句没有抛出异常则会跳出try-catch语句


        }catch (ArithmeticException e){   //小括号里是放入可能会捕捉到的异常类 e

            System.out.println("处理异常");  //catch花括号内是我们自行处理异常的方法

        }finally {
            System.out.println("无论是否捕捉到异常都一定会执行的代码");   //finally里的语句无论是否检测到异常都会执行的语句
        }

        System.out.println("处理完异常后的代码执行");  //这是处理异常后才会执行的语句
                                                 // 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
                                               //如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行


    }



}

1. try的花括号内是放入可能会抛出异常的语句， 如果里面的语句没有抛出异常则会跳出try-catch语句
2. catch的小括号里是放入可能会捕捉到的异常类 e，catch花括号内是我们自行处理异常的方法
3. catch-catch-finally外的语句：当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行，如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行

---

4. ** finally **

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

public static int getData() {
    Scanner sc = null;
    try {
        sc = new Scanner(System.in);
        int data = sc.nextInt();
        return data;
    } catch (InputMismatchException e) {
        e.printStackTrace();
    } finally {
        System.out.println("finally中代码");
    }
    System.out.println("try-catch-finally之后代码");
    if (null != sc) {
        sc.close();
    }


    return 0;
}

public static void main(String[] args) {
    int data = getData();
    System.out.println(data);
}

上述程序，如果正常输入，成功接收输入后程序就返回了，try-catch-finally之后的代码根本就没有执行，即输入流 就没有被释放，造成资源泄漏。

---

自定义异常类

使用的较多的异常类往往是我们自己定义的比较多，那么如何自定义异常类呢，下面我们就来讲讲如何自定义异常类。

class textException extends RuntimeException{

    public textException() {
    }

    public textException(String message) {
        super(message);
    }
}




public class Test1 {

    public static void main(String[] args) {
        int a=0;
        if(a==0){
            throw new textException();
        }
    }

}

如上我们只需让自己创建出的类继承Exception或其它异常类即可，这样这个类也是一个异常类了。
然后我们在需要抛出异常时，抛出自己定义的异常即可。
也可以用try-catch进行使用解决自己定义的异常。
注意事项：

• ** 自定义异常通常会继承自 Exception 或者 RuntimeException **
• **继承自 Exception 的异常默认是受查异常 **
• **继承自 RuntimeException 的异常默认是非受查异常 **

---

异常的处理流程

关于 “调用栈” 方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在 JVM 中有一块内存空间称为 “虚拟机栈” 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的 方式查看出现异常代码的调用栈. 如果本方法中没有合适的处理异常的方式, **就会沿着调用栈向上传递 **

public class Test {


    public static final void func1(){

        int[] a={1,2,3,4,5};
        a[10] = 100;



    }

    public static void main(String[] args) {
        try {
           func1();
            System.out.println("hello world");
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            System.out.println("没能合适解决异常");

        }

    }
}

如上图：在func1中如果没进行处理，堆栈就会延栈调用，也就是图中又看mian方法中是否能够处理好异常，一直向上传递如果都无法解决，一旦交给JVM处理那么程序将会终止，就不会进行之后的代码。

异常类与if的区别

首先我们来说说if在应对程序的应用是怎样的？
if语句：
比如：下面代码我们的if就是在检测到b==0时,就不让程序继续进行下面的计算。
这属于一种事先防卫型，就是避免错误发生。在发生之前就将程序阻断。

package demo1;

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        
        if(b==0){
            System.out.println("分母为0，数字不合法");
        }else {
            System.out.println("a/c= "+a/b);
        }
        
        
    }
}

---

异常类：
如下：异常类相比于if更像是先斩后奏型，事后处理型，在程序发现问题时在进行处理问题，如下代码将可能有异常的语句放到try括号中，如果出现异常在进行解决：

package demo1;

public class Test1 {

    public static void main(String[] args) {
        int a=10;
        int b=0;
        try{
            System.out.println("a/c= "+a/b);
        }catch (ArithmeticException e){
            System.out.println("捕捉到异常并解决异常的方法");
        }
    }
}