Java的异常Exception

异常

1、异常概述与异常体系结构

1.1、异常概述

异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”（开发过程中的语法错误和逻辑错误不是异常）

Java程序在执行过程中所发生的异常事件可分为两类：

• Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverFlowError和OutOfMemory。一半不编写针对性的代码进行处理。
• Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。如：
  • 空指针访问
  • 试图图区不存在的文件
  • 网络连接中断
  • 数组角标越界

编译时异常：执行javac.exe命令时，可能出现的异常

运行时异常 ：执行java.exe命令时，出现的异常

1.2、异常体系结构

java.lang.Throwable
        |-----java.lang.Error: 一半不编写针对性的代码进行处理
        |-----java.lang.Exception: 可以进行异常的处理
            |------编译时异常(checked)
                    |-----IOException
                        |-----FileNotFoundException
                    |-----ClassNotFindException
            |------运行时异常(unchecked, RuntimeException)
                    |-----NullPointerException
                    |-----ArrayIndexOutOfBoundsException
                    |-----ClassCastException
                    |-----InputMismatchException
                    |-----NumberFormatException
                    |-----ArithmeticException

关于异常的举例：

见 package cs20230321.java1;

//--------以下是编译时异常----------------
//IOException
public void test7() {
    File file = new File("hello.txt");
    FileInputStream fis = new FileInputStream(file);

    int data = fis.read();
    while (data != -1){
        System.out.println((char) data);
        data = fis.read();
    }
    fis.close();//流资源需要显式的有关闭操作
}

//--------以下是运行时异常----------------
//ArithmeticException
public void test6(){
    int a = 10;
    int b = 0;
    System.out.println(a/b);//不符合算法的要求
}

//InputMismatchException
public void test5(){
    Scanner scanner = new Scanner(System.in);
    int score = scanner.nextInt();//当输入不是数字时会报异常
    System.out.println(score);
}

//NumberFormatException
public void test4(){
    String str4 = "123zxc";
    int n4 = Integer.parseInt(str4);
    System.out.println(n4);
}
//ClassCastException
public void test3(){
    Object o= new Date();//多态
    String  str3 = (String) o;//转为Object的子类
}
public void test1(){
    //NullPointerException 1
    int[] arr = null;
    System.out.println(arr[3]);
    //NullPointerException 2
    String str = "abc";
    str = null;//对象是空的，所以空指针异常
    System.out.println(str.charAt(0));//获取首位置上的字符
}

//ArrayIndexOutOfBoundsException
public void test2(){
    int[] arr1 = new int[10];
    System.out.println(arr1[10]);

    String str = "abc";
    //StringIndexOutOfBoundsException
    System.out.println(str.charAt(3));//获取首位置上的字符
}

2、异常处理

联系 “ 狼来了”

异常的处理：抓抛模型

• 过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。
  —旦抛出对象以后，其后的代码就不再执行。

  关于异常对象的产生：

  1. 系统自动生成的异常对象
  2. 手动的生成一个异常对象，并抛出（throw）

• 过程二：“抓”：可以理解为异常的处理方式：① try-catch-finally ② throws

2.1、try-catch-finally

格式：

try{
    //可能出现异常的代码
        }catch(异常类型1 变量名1){
            //处理异常的方式 1
        }catch(异常类型2 变量名2){
        //处理异常的方式 2
        }catch(异常类型3 变量名3){
        //处理异常的方式 3
        }
        ...
        finally{
            //一定会执行的代码
        }

说明：

1. finally是可选的

2. 使用try将可能出现异常的代码包起来，在执行过程中，一旦出现异常，就会生成应该对应异常类的对象，根据此对象的类型，去catch中进行匹配

3. 一旦try中的异常对象匹配到某一个cacth时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况）。继续执行其后的代码

4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。

   catch中的异常类型如果有子父类关系，则要求子类一定声明在父类的上面，否则，报错

5. 常用的异常对象处理的方式：① String getMessage() ② printStackTrace();

6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用

7. try-catch-finally结构可以相互嵌套

体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

体会2 ：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，我们说一定要考虑异常的处理。

2.1.1、finally

1. finally是可选的
2. finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch 中有 return 语句等情况。
3. 像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

2.1.2、面试题（待完善）

• throw和 throws的区别？

throw 表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。

throws属于处理异常的一种方式，声明在方法的声明处。

• final 、finally、finalize三者的区别？

final：关键字，修饰属性、方法

finally：关键字，用于处理异常时

finalize：方法名

还有其他类似的。如：

• Collection、 Collections
• String、 StringBuffer、 StringBuilder
• ArrayList、 LinkedList
• HashMap、 LinkedHashMap
• 重写 、重载

结构不相似的：

• 抽象类、接口
• ==、equals（）
• sleep() 、wait()

2.2、throws + 异常类型

1. “throws + 异常类型 ” 写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦方法体执行时，出现异常，扔会在代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行。

体会：

• try-catch-finall ：真正的将异常给处理调了。
• throws的方式只是将异常抛给了方法的调用者，并没有真正将异常处理掉。

开发中，如何选择使用 try-catch-finall 还是 throws ？

1. 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finall 方式处理。
2. 执行的方法 a 中，先后 又调用了另外的几个方法，这几个方法是递进关系执行的，我们建议使用throws的方式进行处理。而执行的方法 a 可以考虑使用try-catch-finall 方式进行处理。

2.3、方法重写的规则

1. 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

2.4、手动的生成一个有异常对象

在方法中 throw new Exception，然后再 e.getMessage() 获取message

package cs20230322;

public class StudentTest {
    public static void main(String[] args) {
        try {
            Student s = new Student();
            s.regist(-1001);
            System.out.println(s);
        }catch (Exception e){
            System.out.println(e.getMessage());//message传的就是 "您输入的数据非法！"
        }
    }
}

class Student{
    public int id;
    public void regist(int id) throws Exception {
        if (id > 0){
            this.id = id;
        }else {
            //手动生成异常
            //在方法内，生成一个异常对象
            throw new Exception("您输入的数据非法！");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

2.5、如何自定义异常类？

步骤：

1. 继承于现有的异常结构：RuntimeException、Exception
2. 提供全局常量：serialVersionUID
3. 提供重载的构造器

2.6、总结

上游排污：污：异常，是throw排出来的污水（制造污水）

下游治污：处理异常，处理的方案是直接往上面报，并没有真正的处理掉异常（治理污水）