十二、异常处理机制（完结）

十二、异常处理机制

---

12.1 异常处理的引入

---

public class Exception01 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;


        //问题：1. 执行到 int res = num1 / num2; 语句就程序异常，无法继续往下执行下一条语句
        //      2. 出现一个小问题就终止程序运行，这样不好，无法保证代码的健壮性
        //解决：异常捕获，选中出异常的代码 Ctrl + Alt + t ，选中 try - catch
        try {
            int res = num1 / num2; //ArithmeticException: / by zero
        } catch (Exception e) {
            //e.printStackTrace(); //这里对捕获的异常进行处理
            System.out.println(e.getMessage()); //打印异常信息
        }

        System.out.println("程序继续运行....");
    }
}

12.2 异常介绍

---

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

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

• Error（错误）：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError [栈溢出]和 OOM（out of memory），Error 是严重错误，程序会崩溃。

• Exception ：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception 分为两大类：

  • 运行时异常（程序运行时，发生的异常）
  • 编译时异常（编程时，编译器检查出的异常）

12.3 异常体系图（重点！）

---

12.3.1 异常体系图

快捷键：

• Ctrl + Alt + B 显示实现类
• Ctrl + Alt + P 显示父类

12.3.2 异常体系图小结

1. Exception 分为两大类：运行时异常、编译时异常
2. 运行时异常，编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException 类及它的子类都是运行时异常
3. 对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
4. 编译时异常，是编译器要求必须处置的异常。

12.4 常见的运行时异常

---

12.4.1 五种常见的运行时异常

• NullPointerException 空指针异常
• ArithmeticException 数学运算异常
• ArrayIndexOutOfBoundsException 数组下标越界异常
• ClassCastException 类型转换异常
• NumberFormatException 数字格式不正确异常

12.4.2 NullPointerException 空指针异常

介绍：当应用程序试图在需要对象的地方使用 null 时，抛出该异常

案例：

public class NullPointerException_ {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length()); //NullPointerException
    }
}

12.4.3 ArithmeticException 数学运算异常

介绍：当出现异常的运算条件时，抛出此异常

案例：

public class ArithmeticException_ {
    public static void main(String[] args) {
        System.out.println(1 / 0); //ArithmeticException: / by zero
    }
}

12.4.4 ArrayIndexOutOfBoundsException 数组下标越界异常

介绍：用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引

案例：

public class ArrayIndexOutOfBoundsException_ {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        for (int i = 0; i <= nums.length; i++) {
            System.out.println(nums[i]); //ArrayIndexOutOfBoundsException: 3
        }
    }
}

12.4.5 ClassCastException 类型转换异常

介绍：当试图将对象强制转换为不是实例的子类时，抛出该异常

案例：

public class ClassCastException_ {
    public static void main(String[] args) {
        A a1 = new B();
        B b = (B)a1;
        C c = (C)a1; //ClassCastException

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

12.4.6 NumberFormatException 数字格式不正确异常

介绍：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常

案例：

public class NumberFormatException {
    public static void main(String[] args) {
        String name = "赵四";
        int num = Integer.parseInt(name); //NumberFormatException: For input string: "赵四"

    }
}

12.5 常见的编译异常

---

12.5.1 介绍

编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译。

12.5.2 常见的编译异常

• SQLException 操作数据库时，查询表可能发生异常
• IOException 操作文件时，发生的异常
• FileNotFoundException 当操作一个不存在的文件时，发生异常
• ClassNotFoundException 加载类，而该类不存在时，异常
• EOFException 操作文件，到文件末尾，发生异常
• IllegalArguementException 参数异常

12.5.3 案例说明

public class FileNotFoundException_ {
    public static void main(String[] args) {
        try {
            FileInputStream fis;
            fis = new FileInputStream("d:\\aa.jpg");
            int len;
            while ((len = fis.read()) != -1) {
                System.out.println(len);
            }
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

12.6 异常处理

---

12.6.1 异常处理介绍

异常处理就是异常发生时，对异常处理的方式，有两种：

• try - catch - finally：在代码中捕获异常，对异常进行处理
• throws： 将发生的异常抛出，返回给调用该代码的方法，最顶级的调用者是 JVM

12.6.2 异常处理的示意图

12.7 try - catch 异常处理

---

12.7.1 try - catch 异常处理介绍

介绍：Java 提供 try 和 catch 块来处理异常。try 块用于包含可能出错的代码。catch 块用于处理 try 块中发生的异常。可以根据需要在程序中有多个 try..catch 块。

语法：

try {
    //可能出现异常的代码
} catch (异常) {
    //对捕获的异常进行处理
} finally {
    //是否有异常都会执行 finally
    //finally 可不写
}

12.7.2 try - catch 注意事项

• 异常发生，后面的代码不执行，直接跳到 catch 代码块
• 异常没发生，不执行 catch 代码块
• 不管异常发没发生，都会执行 finally 代码块，一般在 finally 代码块进行资源释放操作

public class TryCatchDetail {
    public static void main(String[] args) {
        //1. 异常发生，后面的代码不执行，直接跳到 catch 代码块
        //2. 异常没发生，不执行 catch 代码块
        //3. 不管异常发没发生，都会执行 finally 代码块，一般在 finally 代码块进行资源释放操作
        try {
            String str = "111";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
            System.out.println("异常信息 = " + e.getMessage());
        } finally {
            System.out.println("finally 代码块被执行...");
        }
        System.out.println("程序继续...");
    }
}

• 当 try 代码块可能有多个异常，可以用不同的 catch 来捕获，分开处理（注意：子类异常捕获要写在父类异常前面）

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

        //1. 当try代码块可能有多个异常，可以用不同的catch来捕获，分开处理
        //2. 注意，子类异常捕获要写在父类异常前面
        try {
            Person person = new Person();
            person = null;
            System.out.println(person.getName()); //空指针异常
            int n1 = 10;
            int n2 = 0;
            System.out.println("程序执行到此处...");
            int res = n1 / n2; //算数异常
        } catch (NullPointerException e) {
            System.out.println("空指针异常 = " + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("算术异常 = " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name = "jack";

    public String getName() {
        return name;
    }
}

• 可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。

  • 应用场景：就是执行一段代码，不管是否发生异常， 都必须执行某个业务逻辑

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

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

12.7.3 练习

12.7.4 try-catch-finally 执行顺序小结

• 如果没有出现异常，则执行 try 块中所有语句，不执行 catch 块中语句，如果有 finally ，最后还需要执行 finally 里面的语句
• 如果出现异常，则 try 块中异常发生后，try 块剩下的语句不再执行。将执行 catch 块中的语句，如果有 finally ，最后还需要执行 finally里面的语句

12.8 throws 异常处理

---

12.8.1 基本介绍

• 如果一个方法（中的语句执行时）可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
• 在方法声明中用 throws 语句可以声明抛出异常的列表，throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

12.8.2 快速入门

public class Throws_ {
    //public static void main(String[] args) throws FileNotFoundException { //可以抛出产生的异常类型
    //public static void main(String[] args) throws Exception { //也可以抛出父类异常
	public static void main(String[] args) throws FileNotFoundException, NullPointException { //还可以抛出多个异常
        //读文件的操作可能产生FileNotFoundException类型的异常
        //创建文件流对象
        FileInputStream fis = new FileInputStream("d://aa.txt");
    }
}

12.8.3 throws 异常处理细节

• 对于编译异常，程序中必须处理，比如 try-catch 或者 throws
• 对于运行时异常，程序中如果没有处理，默认就是 throws 的方式处理
• 子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型
• 在 throws 过程中，如果有方法 try-catch ，就相当于处理异常，就可以不必 throws

public class ThrowsDetail {
    public static void main(String[] args) {
        A.methodA();
        B.methodB();
    }
}
//1）对于编译异常，程序中必须处理，比如try-catch 或者throws
class A {
    //public void methodA() throws FileNotFoundException {
    public static void methodA() /* throws FileNotFoundException */ {
        //此处报编译异常，必须抛出或 try - catch
        try {
            FileInputStream file = new FileInputStream("d://a.txt"); //FileNotFoundException
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

//2）对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
class B {
    public static void methodB() /*throws NullPointerException */{
        String name = "123";
        name = null;
        name.length(); //NullPointException 运行时异常，可不手动处理，默认会 throws NullPointException给调用处
    }
}

//3）子类重写父类的方法时，对抛出异常的规定：
//   子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，
//   要么为父类抛出的异常的类型的子类型
class Father {
    public void method() throws RuntimeException { }
}

class Son extends Father{
    @Override
    //public void method() throws Exception { //报错 此处必须为 Father 类方法抛出的异常的子类或一致
    //public void method() throws FileNotFoundException { //和父类的方法抛出的异常不是父子类关系
    public void method() throws RuntimeException {

    }
}

//4）在throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必throws，二选一

12.9 自定义异常

---

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

步骤：

• 定义类：自定义异常类名（程序员自己写）继承 Exception 或 RuntimeException

要点：

• 如果继承 RuntimeException，属于运行异常（一般来说，继承 RuntimeException，比较方便处理）
• 如果继承 Exception ，属于编译异常，处理比较麻烦

案例：

public class CustomException {
    public static void main(String[] args) /*throws AgeException*/ { //如果自定义的异常是编译异常，处理比较麻烦
        int age = 1111;

        //要求范围在 18 – 120 之间，否则抛出一个自定义异常
        if (age < 18 || age > 120) {
            //这里可以通过构造器，设置提示信息
            throw new AgeException("age必须在 18 - 20 之间"); //提示：AgeException: age必须在 18 - 20 之间
        }
    }
}

//自定义 AgeException 异常
//1. 一般自定义异常是继承 RuntimeException ,可以用 RuntimeException 的现有处理机制，比较方便
//2. 如果继承 Exception 就是编译异常，处理比较麻烦
public class AgeException extends RuntimeException {
//public class AgeException extends Exception {
    public AgeException(String message) {
        super(message);
    }
}

12.10 throw 和 throws 的区别

---

12.11 练习

---

• 编写应用程序EcmDef.java，接收命令行的两个参数（整数），计算两数相除。
• 计算两个数相除，要求使用方法 cal（int n1，int n2）
• 对数据格式不正确（NumberformatException）、缺少命令行参数（ArraylndexOutOfBoundsException）、除0进行异常处理（ArithmeticException）。