什么是异常#

简单来说异常就是用来表示Java程序运行过程中的错误(信息)

网络中断, 用户输入信息, 读取不存在的文件

异常体系与分类#

在Java中Throwable作为所有错误跟异常的祖先类

根据错误的严重程度分

• Error,: 比较严重的错误(代码处理不了, Jvm内部资源耗尽的错误) java.lang.StackOverflowError 栈溢出 java.lang.OutOfMemoryError 堆溢出
• Exception: 错误程度小, 能够用代码进行处理
  • java.lang.ArithmeticException: / by zero 算数异常 /0
  • java.lang.NullPointerException 空指针异常
  • java.lang.ArrayIndexOutOfBoundsException 数组越界

根据处理方式的不同

• 编译时异常(checked) : 编译阶段就会出现异常提醒,编译不通过
• 运行时异常(unchecked): 编译通过, 但是运行时可能会出错(RuntimeException及其子类)

编译时异常与运行时异常有啥区别?

• 运行时异常本身及其所有子类都是运行时异常,编译阶段不报错,程序运行时出现的,一般由于逻辑错误或者参数传递错误造成
• 编译时异常:除了RuntimeException本身及其子类外的其他的异常都是编译时异常,作用在于提醒程序员检查.

Exception是运行时异常还是编译时异常

• Exception是编译时异常和运行时异常的父类
• 在自定义异常的时候,Exception作为编译时异常

异常的作用

1. 查询bug报错信息
2. 可以作为方法内部的一种特殊返回值,以便通知调用者底层执行的情况

常见异常#

1
常见异常
2
    编译时异常:
3
        java.lang.CloneNotSupportedException 克隆异常
4
        java.io.FileNotFoundException  找不到文件
5
        java.io.IOException IO操作异常
6
    运行时异常
7
        java.lang.ArithmeticException 算数异常
8
        java.lang.NullPointerException 空指针异常
9
        java.lang.ArrayIndexOutOfBoundsException 数组越界异常
10
        java.lang.NumberFormatException  数字格式化异常
11
        java.lang.ClassCastException 类型转换异常

jvm默认处理机制#

jvm默认异常处理流程

1. 当我们代码在执行到，发生错误的地方。
2. 一旦发生错误，jvm就会终止我们自己程序的运行，转而执行jvm自己的错误处理流程
3. 在发生错误地方，收集错误信息，产生一个描述错误的对象
4. 访问收集到的错误信息，将错误信息，输出到控制台窗口中(哪个线程,异常类型名, 异常原因, 哪个类哪个方法哪一行报错了)

执行过程

• 如果错误产生在main方法中
  • 当我们的代码执行到错误行数之前，代码是正常执行的
  • 当我们的代码执行到错误行数时，JVM会终止程序的执行，抛出一个该异常信息封装成的对象
  • 将该对象中的异常信息，打印到控制台上，告诉程序员发生了什么问题
  • 发生错误之后的语句，都不执行了
• 如果错误产生在main方法当中的另一个方法中
  • 当程序执行到该方法的错误行数时，JVM会终止程序的执行
    • 向上给方法的调用者抛出一个该异常信息封装成的对象
  • 一直向上抛出，直到抛给main方法，main方法最终抛给JVM
  • 发生异常之前的语句正常执行，但是之后的语句都不执行了
• 默认处理机制仅针对运行时异常

捕获异常,自己处理#

1
方式一:
2
try{
3
   // 可能出现异常的代码
4
}catch(异常类型 对象名){
5
   // 对异常的处理操作
6
}
7
方式二:
8
try{
9
   // 可能出现异常的代码
10
}catch(异常类型1 | 异常类型2 | 异常类型3 | 对象名){
11
   // 对异常的处理操作
12
}

1
//获取异常信息，返回字符串。
2
getMessage()
3
//获取异常类名和异常信息，返回字符串。
4
toString()
5
//获取异常类名和异常信息，以及异常出现在程序中的位置,并打印到控制台
6
printStackTrace()

1
try{
2
   // 可能出现异常的代码
3
}catch(异常类型 对象名){
4
   // 对异常的处理操作
5
}catch(异常类型 对象名){
6
   // 对异常的处理操作
7
}catch(异常类型 对象名){
8
   // 对异常的处理操作
9
}.....

1
        try {
2
            // 出现异常的代码
3
        } catch (ArithmeticException e) {
4
            System.out.println("xxxxxxx");
5
        } catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
6
            System.out.println("sssssss");
7
        }

抛出异常,上层处理#

当方法中出现了异常, 方法就没有继续执行下去的意义了, 可以选择抛出异常处理.

让该方法结束运行并告诉调用者发生了什么问题.

1
修饰符  返回值 方法名(形参列表)  throws 异常列表 {}

1
throw 异常对象 (new 出来的)

异常策略选择#

总结一下，目前为止，我们学习过的异常处理策略有2种：

• 捕获并处理try-catch
• 向上抛出
  • 运行时异常，自动抛出，直道抛给jvm
  • 编译时异常，需要结合throws关键字向上抛

如何选择策略？

• 对于运行时异常，我们不应该写出产生这种异常的代码，应该在代码的测试阶段修正代码或者选择在方法调用处统一处理.
• 对于编译时异常，功能内部能够处理的就处理，如果不能够或者没有必要处理，就抛出,由方法调用处统一处理.

finally#

特点

被finally控制的语句体一定会执行 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

作用

用于释放资源，在IO流操作和数据库操作中会见到 close()

如何使用

跟try-catch结合

1
语法:方式一
2
try{
3

4
}catch(){
5

6
}catch(){
7

8
}.....
9
finally{
10
    // 一定执行
11
}
12

13
方式二:
14
try{
15

16
}finally{
17

18
}

一些奇思妙想

• try代码块如果有return
  • 程序会先执行完finally代码块，回过头执行try中的return
• catch代码块中如果有return，并且catch正常捕获异常执行
  • 程序会先执行完finally代码块后，再回去执行catch中return，从catch代码块中结束方法
• finally代码中有return
  • 不会影响finally代码块执行
• 如果finally和catch中都有return
  • 程序会直接从finally代码块中的return结束方法
• 如果try中的异常不能正常捕获,但是finally中有return
  • 注意此时程序会跳过这个异常，不会抛出异常给JVM报错

final与finally有什么区别

• final关键字，最终的，最后的。可以修饰类 成员变量 成员方法
  • 修饰类，该类不能被继承
  • 修饰变量表示一个常量
  • 修饰方法表示无法重写的方法
• finally代码块，和try…catch一起使用，具有必然执行的特点
  • 异常处理体系当中，用于资源释放

为什么要自定义异常#

现有的异常体系不满足需求

如何自定义异常#

1
package _15exception.com.cskaoyan._06define;
2

3
import java.util.Scanner;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/14 16:06
9
 **/
10
/*
11
考试成绩必须在0-100分之间，如果有考试成绩不在这个范围之内，则认为成绩异常。
12
 */
13
public class Demo {
14
    public static void main(String[] args) {
15
        try {
16
            func();
17
        } catch (MyException1 myException1) {
18
            myException1.printStackTrace();
19
        }
20
    }
21

22
    private static void func() throws MyException1 {
23
        // 键盘接收分数
24
        Scanner scanner = new Scanner(System.in);
25
        int score = scanner.nextInt();
26
        // 判读一下是否在区间内
27
        if (score < 0 || score > 100) {
28
            // 如果不在 抛出异常
29
            // throw + 异常对象
30
            throw new MyException1("分数不合法");
31
        }
32
    }
33
}
34

35
// 定义编译时异常
36
class MyException1 extends Exception{
37
    public MyException1() {
38
    }
39

40
    public MyException1(String message) {
41
        super(message);
42
    }
43
}
44

45
// 定义运行时异常
46
class MyException2 extends RuntimeException{
47
    public MyException2() {
48
    }
49

50
    public MyException2(String message) {
51
        super(message);
52
    }
53
}