Java中异常的详细讲解与细节讨论

用一个代码引出异常为什么要使用异常

代码：

public static void main(Sting args[]){
    int n1 = 1;
    int n2 = 0;
    System.out.println(n1/n2);//这里会抛ArihmaticException,因为除数不能为0,若未用异常处理机制则程序直接结束，后面的代码将不执行。这样很不好，我们不能因为一个非致命的错误而结束整个程序
    .
    .
    .
}

异常的基本介绍：

在Java中，异常是指在程序执行过程中发生的错误或异常情况。Java中的异常处理机制允许我们捕获和处理这些异常，以便程序能够继续执行或进行适当的处理。

异常分为两类：

（1）编译时异常，是编译器要求解决的异常，必须解决，否则程序跑不起来。如：ClassNotFounfException(找不到类异常)...

（2）运行时异常，编译器检查不出来，一般是指编程时的逻辑错误，程序员应当避免。如：NullPointerException(空指针异常),ArithmeticException(数学运算异常),ArrayIndexOutOfBoundsException(数组下标越界异常),ClassCastException(类型转换异常),NumberFormatException(数字格式不正确异常)...

NullPointerException(空指针异常)代码：

public class NullPointException {
    public static void main(String[] args) {
        //当应用程序试图在需要对象的地方使用null时，抛出该异常
        String name1 = null;
        String name2 = "";
        try {
            System.out.println(name1.length());//空指针
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(name2.length());

    }
}

ArithmeticException(数学运算异常)代码：

public class ArithmeticException {
    public static void main(String[] args) {
        //当出现异常的运算条件时，抛出此异常
        int n1 = 1;
        int n2 = 0;
        try {
            System.out.println(n1/n2);//除数不能为0
        } catch (Exception e) {
//            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}

ArrayIndexOutOfBoundsException(数组下标越界异常)代码：

public class ArrayIndexOutOfBoundsException {
    public static void main(String[] args) {
        //用非法索引访问数组时抛出的异常
        int[] array = {1,2,3};
        for (int i = 0; i <= array.length; i++) {
            System.out.println(array[i]);//数组越界了,。没有array[3]
        }
    }
}

ClassCastException(类型转换异常)代码：

public class ClassCastException {
    public static void main(String[] args) {
        A b = new B();//向上转型
        B b2 = (B)b;//向下转型
        //当试图将对象强制转换为不是实例的子类时，抛出该异常
        C c = (C) b;//这里会抛出ClassCastException,因为B类和C类没有关系,并不能类型转换
    }
}

class A{}
class B extends A{}
class C extends A{}

NumberFormatException(数字格式不正确异常)代码：

public class NumberFormatException {
    public static void main(String[] args) {
        String name2 = "123";
        int n2 = Integer.parseInt(name2);
        System.out.println(n2);

        //当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常
        //当要把字符串转换为数字时,但是该字符串不能转换为数字时抛出的异常
        String name1 = "ret";
        int n1 = Integer.parseInt(name1);//这里会抛出NumberFormatException,因为ret不能转换为数字
        System.out.println(n1);

    }
}

异常处理方式：

（1）try-catch-finally，程序员在代码中捕获发生的异常，自行处理。(就地解决)

（2）throws，将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者是JVM，而JVM的处理就是直接报错，结束程序

try-catch-finally处理机制示意图：

throws处理机制示意图：

try-catch-finally细节讨论：

（1）如果try块中的异常发生了，则异常发生后面的代码不会执行，直接进入到 catch 块

（2）如果异常没有发生，则顺序执行 try 的代码块，不会进入到 catch块中

（3）如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则将代码放在finally块中

代码：

public static void main(String args[]){
    try {
            String str = "ret";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (Exception e) {
            System.out.println("异常信息=" + e.getMessage());
        } finally {
            System.out.println("finally的代码块被执行");
        }
    System.out.println("程序继续...");
    
}
/*
输出结果：
    异常信息=For input string: "ret"
    finally的代码块被执行
    程序继续...
*/

(4)可以有多个catch语句，捕获不同的异常(进行不同的业务处理)，要求父类异常在后，子类异常在前

代码：

public class TryCatchFinallyDetails {
    public static void main(String[] args) {
        //1.如果 try 代码块有可能有多个异常
        //2.可以使用多个 catch 分别捕获不同的异常，相应处理
        //3.要求子类异常写在前面，父类异常写在后面
        try {
            People people = new People();
            System.out.println(people.getName());//NullPointerException
            int n1 = 10;
            int n2 = 0;
            int res = n1 / n2;//ArithmeticException
        } catch (NullPointerException e) {
            System.out.println("空指针异常=" + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("算术异常=" + e.getMessage());
        } catch (Exception e) {//Exception是ArithmeticException和NullPointerException的父类
            System.out.println(e.getMessage());
        } finally {
            System.out.println("执行finally语句");
        }
    }
}

class People {
    private String name = "ret";
    public String getName() {
        return name;
    }
}

/*
    输出结果：
    ret
    算术异常=/ by zero
    执行finally语句
*/

（5）可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑

代码：

public static void main(String[] args) {
/*
可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，
因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，
都必须执行某个业务逻辑
*/
    try {
        int n1 = 10;
        int n2 = 0;
        System.out.println(n1 / n2);
    } finally {
        System.out.println("执行了 finally..");
    }
        System.out.println("程序继续执行..");
}

throws细节讨论：

（1）对于运行时异常，程序中如果没有处理，默认就是throws的方式处理

（2）子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么抛出的异常类型是父类抛出异常的子类型

（3）在throws过程中，如果有try_catch，就相当于处理异常了，就不必throws了

代码：

package com.example.retcode.test.exception.throws_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
 * @author ruientao
 * @version 1.0
 * 2023/8/21 21:11
 * @description TODO
 */
public class ThrowsDetails {
    public static void main(String[] args) {
        f2();
    }

    public static void f2() /*没有进行try_catch处理异常,就默认了throws,而且是throws ArithmeticException*/ {
        //1.对于编译异常,程序中必须处理,比如try-catch或者throws
        //2.对于运行时异常,程序中如果没有处理,默认就是throws的方式处理
        int n1 = 10;
        int n2 = 0;
        double res = n1 / n2;
    }

    public static void f1() throws FileNotFoundException {
        //调用f3()会报错
        //1. 因为 f3() 方法抛出的是一个编译异常,即这时,就要 f1() 必须处理这个编译异常,在f1()中,要么try-catch-finally,或者继续throws这个编译异常
        f3(); // 抛出异常
    }

    public static void f3() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("d://java.txt");
    }

    public static void f4() {
        //在 f4()中调用方法f5()是可以的,原因是f5()抛出的是运行异常
        //在java中,并不要求程序员显示处理,因为有默认处理机制
        f5();
    }

    public static void f5() throws ArithmeticException {
    }
}

class Father { //父类
    public void method() throws RuntimeException {
    }
}

class Son extends Father {//子类

    //子类重写父类的方法时,对抛出异常的规定:子类重写的方法,所抛出的异常类型要么和父类抛出的异常一致,要么为父类抛出的异常类型的子类型
    //在throws过程中,如果有方法try-catch,就相当于处理异常,就可以不必throws
    @Override
    public void method() throws ArithmeticException {
    }
}

自定义异常:

当程序中出现了某种错误，但是错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息

细节讨论：

（1）自定义异常类名(程序员自己定)，继承Exception或RuntimeException

（2）如果继承Exception，属于编译异常，如果继承RuntimeException，属于运行异常(一般来说继承RuntimeException，好处时，我们可以使用默认的处理机制，比较方便)

代码：

public class CustomException {
    public static void main(String[] args) /*throws AgeException*/ {
        int age = 158;
        //要求范围在 18 – 120 之间，否则抛出一个自定义异常
        if (!(age >= 18 && age <= 120)) {
            //这里我们可以通过构造器，设置信息
            try {
                throw new AgeException("年龄需要在 18~120 之间");
            } catch (AgeException e) {
                System.out.println(e.getMessage());
            }
        } else {
            System.out.println("你的年龄范围正确:" + age + "岁");
        }
    }
}

class AgeException extends RuntimeException {
    public AgeException(String message) {//构造器
        super(message);
    }
}

throw 和 throws 的区别：