Java 异常

一、为什么需要处理异常

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 0;
    int res = num1 / num2;
    System.out.println("程序继续运行....");
}

//1. num1 / num2 => 10 / 0
//2. 当执行到 num1 / num2 因为 num2 = 0, 程序就会出现(抛出)异常 ArithmeticException
//3. 当抛出异常后，程序就退出，崩溃了 , 下面的代码就不在执行
//4. 大家想想这样的程序好吗? 不好，不应该出现了一个不算致命的问题，就导致整个系统崩溃
//5. java 设计者，提供了一个叫“异常处理机制”来解决该问题

---

二、异常介绍

运行异常（编译器检查不出来）

• 编程时的逻辑错误，是程序员应该避免的异常
• java.lang.RuntimeException类及其子类都是运行异常
• 可以不作处理

编译异常

• 是编译器要求必须处理的异常，否则代码不能通过编译

1.常见的运行异常

• NullPointerException 空指针异常：当应用程序试图在需要对象的地方使用 null 时，抛出该异常
• ArithmeticException 数学运算异常：当出现异常的运算条件时，抛出此异常
• ArrayIndexOutOfBoundsException 数组下标越界异常：用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引
• ClassCastException 类型转换异常：当试图将对象强制转换为不是实例的子类时，抛出该异常
• NumberFormatException 数字格式不正确异常：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常 => 使用该异常我们可以确保输入是满足条件数字.

2.常见的编译异常

---

三、异常处理

异常处理就是当异常发生时，对异常处理的方式。

1. try-catch-finally：程序员在代码中捕获发生的异常，自行处理
2. throws：将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者是JVM

1.try-catch-finally

• 如果异常发生了，则异常发生后面的代码不会执行，直接进入到 catch 块
• 如果异常没有发生，则顺序执行 try 的代码块，不会进入到 catch
• 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码- finally
• 如果 try 代码块有可能有多个异常，以使用多个 catch 分别捕获不同的异常，相应处理。要求子类异常写在前面，父类异常写在后面。如果发生异常，只会匹配一个catch

public class TryCatchDetail02 {
    public static void main(String[] args) {
        try {
            Person person = new Person();
            person = null;
            System.out.println(person.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) {
            System.out.println(e.getMessage());
        
        } finally {
        }
    }
}

class Person {
    private String name = "jack";
    public String getName() {
        return name;
    }
}

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

public class TryCatchDetail03 {
    public static void main(String[] args) {
        try{
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);
        }finally {
            System.out.println("执行了 finally..");
        }
            System.out.println("程序继续执行..");
        }
}

练习

public class TryCatchExercise01 {
    public static int method() {
        try {
            String[] names = new String[3];//String[]数组
            if (names[1].equals("tom")) {//NullPointerException
                System.out.println(names[1]);
            } else {
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//捕获
            return 3;
        } finally { //必须执行
            return 4; //返回4
        }
    }

    public static void main(String[] args) {
        System.out.println(method()); //4
    }
}

public class TryCatchExercise02 {
}

class Exception02 {
    public static int method() {
        int i = 1;
        try {
            i++; //i = 2
            String[] names = new String[3];
            if (names[1].equals("tom")) {//空指针
                System.out.println(names[1]);
            } else {
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {
            return ++i; //i = 3
        } finally {//必须执行
            return ++i; //i = 4
        }
    }

    public static void main(String[] args) {
        System.out.println(method());
    }
}

public class TryCatchExercise03 {
}
class ExceptionExe01 {
    public static int method() {
        int i = 1;//i = 1
        try {
            i++;// i=2
            String[] names = new String[3];
            if (names[1].equals("tom")) { //空指针
                System.out.println(names[1]);
            } else {
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {
            return ++i;  // i = 3 => 保存临时变量 temp = 3;
        } finally {
            ++i; //i = 4
            System.out.println("i=" + i);// i = 4
        }
    }

    public static void main(String[] args) {
        System.out.println(method());// 3
    }
}

//如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止
//思路
//1. 创建Scanner对象
//2. 使用无限循环，去接收一个输入
//3. 然后将该输入的值，转成一个int
//4. 如果在转换时，抛出异常，说明输入的内容不是一个可以转成int的内容
//5. 如果没有抛出异常，则break 该循环

import java.util.Scanner;

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

        Scanner scanner = new Scanner(System.in);
        int num = 0;
        String inputStr = "";

        while (true) {
            System.out.println("请输入一个整数:"); //
            inputStr = scanner.next();
            try {
                num = Integer.parseInt(inputStr); //这里是可能抛出异常
                break;
            } catch (NumberFormatException e) {
                System.out.println("你输入的不是一个整数:");
            }
        }

        System.out.println("你输入的值是=" + num);
    }
}

---

---

2.throws

• 如果一个方法（中的语句执行时）可能生成某种异常，但并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理
• 在方法声明中用 throws 语句可以声明抛出异常的列表，throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
• 对于编译异常，程序中必须处理，比如 try-catch 或者 throws
• 对于运行时异常，程序中如果没有处理，默认就是 throws 的方式处理
• 子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常类型的子类型
• 在 throws 过程中，如果有方法 try-catch , 就相当于处理异常，就可以不必 throws

---

---

3.自定义异常

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

步骤

?举例

public class CustomException {
    public static void main(String[] args) /*throws AgeException*/ {

        int age = 180;
        //要求范围在 18 – 120 之间，否则抛出一个自定义异常
        if(!(age >= 18 && age <= 120)) {
            //这里我们可以通过构造器，设置信息
            throw new AgeException("年龄需要在 18~120之间");
        }
        System.out.println("你的年龄范围正确.");
    }
}
//自定义一个异常
//1. 一般情况下，我们自定义异常是继承 RuntimeException
//2. 即把自定义异常做成 运行时异常，好处时，我们可以使用默认的处理机制
//3. 即比较方便
class AgeException extends RuntimeException {
    public AgeException(String message) {//构造器
        super(message);
    }
}

注意！！！自定义异常是throw，不是throws

throw 和 throws 的区别

---

四、参考

B站 韩顺平零基础学Java