33、Java 异常掌握这些就够了（图解 Java 中的异常）_java异常分类图(1)

于 2024-05-14 13:57:58 发布
阅读量653 收藏 23
点赞数 13
分类专栏： 程序员 文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84181986/article/details/138852600
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

try-catch 处理异常的格式：

public class TryCatch {
    public static void main(String[] args) {
        System.out.println("不可能抛异常的代码1");
        try {
            // try 代码块中放可能抛异常的代码
            System.out.println("该行代码可能抛异常, 如果抛出了异常, 下面的一行代码不会被执行");
            System.out.println("如果上面的代码抛出了异常, 本行代码不执行");
        } catch (NullPointerException e) {
            // 当抛出【空指针异常】的时候会来到该代码块
            System.out.println("抛出了【空指针异常】");
        } catch (ClassCastException e) {
            // 当没有抛出【空指针异常】
            // 但抛出【类转换异常】的时候会来到该代码块
            System.out.println("抛出了【类转换异常】");
        } catch (ArrayIndexOutOfBoundsException e) {
            // 当没有抛出【空指针异常】和【类转换异常】
            // 但抛出【数组下标越界异常】的时候会来到该代码块
            System.out.println("抛出了【数组下标越界异常】");
        } catch (Throwable t) { // Throwable 是所有异常的父类, 只能放子异常的后面
            // 上面的异常没有抛出
            // 且的确抛出了异常, 会来到该代码块
            System.out.println("抛出了异常");
        }
        System.out.println("不可能抛异常的代码2");
    }
}

(2) Throwable 常用方法

看下面代码，思考打印结果：

public class TryCatch {
    public static void main(String[] args) {
        try {
            long[] longs = new long[10\_0000\_0000];
        } catch (OutOfMemoryError e) {
            // output: java.lang.OutOfMemoryError: Java heap space
            System.out.println("\n" + e);

            // output: Java heap space
            System.out.println(e.getMessage());

            // 红色字体, 带异常行定位（控制台输出堆栈信息）
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

🌼 直接打印异常对象【e】：异常类型（java.lang.OutOfMemoryError）和异常信息（Java heap space）
🌼 打印异常对象【e】的 getMessage() 方法的返回值：异常信息（Java heap space）

🌼 直接调用异常对象【e】的 printStackTrace() 方法 【常用】
🌼 有红色打印信息不代表程序退出了

(3) 一个 catch 捕获多种类型的异常

🌼 从 Java7 开始，当个catch可以捕获多种类型的异常
🌼 如果并列的几个异常类型之间存在父子关系，保留父类型即可
🌼 此时异常对象【e】是隐式 final 的

public class TryCatch {
    public static void main(String[] args) {
        try {
            System.out.println("啦啦啦");
            // 可能产生异常的代码
        } catch (OutOfMemoryError | NullPointerException | IndexOutOfBoundsException e) {
            // 产生 OutOfMemoryError 异常、NullPointerException 异常
            // 或 IndexOutOfBoundsException 异常的时候都会来到该代码块
            if (e instanceof OutOfMemoryError) {
                System.out.println(e);
            } else if (e instanceof NullPointerException) {
                System.out.println(e.getMessage());
            } else { // 是 IndexOutOfBoundsException 异常的时候
                e.printStackTrace();
            }
        }
    }
}

(4) Exercise

① 第1题

思考下面的代码的打印结果是什么：

public class Exercise {
    public static void main(String[] args) {
        System.out.println(1);
        Integer integer = new Integer("啦啦啦");
        // 上一行代码抛异常了, 程序终止, 下面的代码不会执行
        System.out.println(2);
    }
}
② 第2题

思考下面的代码的打印结果是什么：

public class Exercise {
    public static void main(String[] args) {
        int n = 6;
        try {
            // 6
            System.out.println(n++);
            Double d = new Double("哈哈哈");
            System.out.println(++n);
            System.out.println(d);
        } catch (NumberFormatException e) {
            e.printStackTrace();
            // 7
            System.out.println(n++);
        }
        // 8
        System.out.println(n);
    }
}

在这里插入图片描述

③ 第3题

思考下面的代码的打印结果是什么：

public class Exercise {
    public static void main(String[] args) {
        int num = 1;
        Integer integer1 = new Integer("111");
        // 111
        System.out.println(num++ + --integer1);
        Integer integer2 = new Integer("嘻嘻嘻");
        System.out.println(integer1 + integer2);
    }
}

在这里插入图片描述

④ 第4题

思考下面的代码的打印结果是什么：

public class Exercise {
    public static void main(String[] args) {
        Integer[] ints = {111, null, 222};
        for (int integer : ints) {
            // 自动拆箱
            // ints[n].intValue();
            // 当 ints[n] 为 null 的时候就抛 NullPointerException 异常
            System.out.println(integer);
        }
        // output: 111
    }
}

在这里插入图片描述

(5) finally

✏️ try或catch代码块中的代码执行完毕后，一定会执行finally代码块中的代码

✏️ finally可以和try-catch搭配使用，也可以和try搭配使用

✏️ 作用：在finally中编写关闭、释放资源的代码（如：关闭文件）

finally 使用格式1：

public class FinallyTest {
    public static void main(String[] args) {
        try {
            System.out.println(1);
        } catch (NullPointerException e) {
            System.out.println(11);
        } finally {
            System.out.println(111);
        }
        
        /\*
 output:
 1
 111
 \*/
    }
}

finally 使用格式2：

public class FinallyTest {
    public static void main(String[] args) {
        try {
            System.out.println(222);
        } finally {
            System.out.println(555);
        }

        /\*
 output:
 222
 555
 \*/
    }
}

往文件写数据的案例：

public class FinallyTest {
    public static void main(String[] args) {
        String file = "C:\\Users\\34657\\Desktop\\fileTest.txt";
        PrintWriter pw = null;
        try {
            // 创建打印写入器（类似打开文件）
            pw = new PrintWriter(file);
            // 往文件中写入内容【愿你万事顺心！】
            pw.write("愿你万事顺心！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 关闭文件资源
            assert pw != null;
            pw.close();
        }
    }
}

(6) finally 细节

✏️ 如果在执行 try 或 catch 的时候，JVM 退出或当前线程被中断（杀死），finally 代码块不会执行

✏️ 如果在 try 或 catch 中使用了 return、break、continue 等提前结束的语句的话，finally 会在 return、break、continue 之前执行

思考下面代码的执行结果：

public class FinallyTest {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            try {
                System.out.println(i + "\_try\_1");
                // continue: 终止此次循环, 继续下次循环
                if (i == 2) continue;
                System.out.println(i + "\_try\_2");
            } finally {
                System.out.println(i + "\_finally");
            }
        }
    }
}

在这里插入图片描述

思考下面代码的执行结果：

public class FinallyTest {
    public static void main(String[] args) {
        // 3
        // 77
        // 11
        System.out.println(t());
    }

    private static int t() {
        try {
            new Integer("好");
            System.out.println(1);
            return 2;
        } catch (Exception e) {
            System.out.println(3);
            return 11;
        } finally {
            System.out.println(77);
        }
    }
}

四、throws 处理异常

(1) throws

✒️ throws：将异常抛给上层方法
✒️ main 方法通过 throws 把异常抛给 JVM 后，程序会终止运行
✒️ 如果 throws 后面的异常类型存在父子关系，保留父类型即可
✒️ 可以一部分异常通过 try-catch 处理，一部分异常通过 throws 处理

public class ThrowsTest {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过 throws 把异常抛给 JVM
        m1();
    }

    private static void m1() throws ClassNotFoundException {
        // 通过 throws 把异常抛给上层方法
        m2();
    }

    private static void m2() throws ClassNotFoundException {
        // 通过 throws 把异常抛给上层方法
        m3();
    }

    private static void m3() throws ClassNotFoundException {
        // 通过 throws 把异常抛给上层方法
        Class.forName("com.oracle.gq.Hello.java");
    }
}

在这里插入图片描述

(2) throws 细节

✒️ 有继承关系的时候，子类重写父类的方法抛出的异常不能大于父类方法抛出的异常（必须是父类方法抛出的异常的子类型）
✒️ 父类方法 throws 了异常，子类重写父类的方法可以不 throws 异常
✒️ 父类方法没有 throws 异常，则子类重写父类的方法一定不能 throws 异常

public class Person {
    public void test1() {
    }

    public void test2() throws IOException {
    }

    public void test3() throws IOException {
    }

    public void test4() throws IOException {
    }
}

class Student extends Person {

    // 父类的 test1 没有 throws 异常, 则子类重写父类的 test1 也不能 throws 异常
    @Override
    public void test1() {
    }

    // 父类的 test2 有 throws 异常, 但子类重写父类的 test2 可以不 throws 异常
    @Override
    public void test2() {
    }

    // 父类的 test3 抛出了 IOException 异常, 子类重写父类的 test3 可以抛出和父类一样的异常
    @Override
    public void test3() throws IOException {
    }

    // 父类的 test4 抛出了 IOException 异常, 子类重写父类的 test4 可以抛出父类异常的子异常
    @Override
    public void test4() throws FileNotFoundException {
    }
}

五、throw 主动抛出异常

📜 使用throw可以抛出一个新建的异常

🌼 问题比较严重的时候抛出检查型异常
🌼 问题不哪么严重的时候抛出非检查型异常

public class Person {
    public Person(String name) throws Exception {
        if (name == null || "".equals(name))
            // Exception 是检查型异常
            throw new Exception("name must not be empty.");
    }
}

class Student {
    public Student(String name) {
        if (name == null || name.length() == 0)
            // IllegalArgumentException 是非检查型异常
            throw new IllegalArgumentException("name must not be empty");
    }
}

六、自定义异常

(1) 自定义检查型异常

📖 若希望开发者重视这个异常、认真处理这个异常，则自定义检查型异常
📖 创建一个类（异常类），并继承 Exception 即可创建一个自定义的检查型异常
📖 检查型异常使用起来比较麻烦（相对非检查型异常来说）

/\*\*
 \* @author 庆医
 \* @describe 自定义检查型异常
 \*/
public class EmptyNameException extends Exception {
    public EmptyNameException() {
        super("name must not be empty!");
    }
}

(2) 自定义非检查型异常

📖 若不严格要求开发者去处理这个异常，则定义为非检查型异常
📖 从创建一个类（异常类），并继承 RuntimeException 即可创建一个自定义的非检查型异常

/\*\*
 \* @author 庆医
 \* @describe 自定义非检查型异常
 \*/
public class IllegalAgeException extends RuntimeException {
    public IllegalAgeException(int age) {
        super("The age you provided is " + age + " [年龄必须大于零]");
    }
}

使用自定义异常：

public class Person {
    private int age;
    private String name;

    public Person(String name) throws EmptyNameException {
        if (name == null || "".equals(name))
            throw new EmptyNameException();
        this.name = name;
    }

    public Person(int age) {
        if (age < 1) {
            throw new IllegalAgeException(age);
        }
        this.age = age;
    }
}

七、使用异常的好处

🔑 将错误处理代码和普通代码区分开
🔑 可以将错误信息传播到调用堆栈中
🔑 可以对错误类型进行区分和分组

八、案例（编写断言类）

📖 断言（assertion）作用：验证软件开发者对某一功能预期的结果

🌼 当程序执行到断言的位置时，会对软件开发者希望测试的功能进行测试。若断言不为真，程序会中止执行（抛异常）；若断言为真，不会抛异常，直接往后执行。

🌼 下面的代码实现了一个简单的计算器类
🌼 用于计算两个数的和，和计算两个数的商
🌼 当计算两个数的商的时候，必须保证第二个参数不为零（在此自定义异常类 DivideException 对第二个参数进行校验）
🌼 考虑到 DivideException 异常类可能只在本类中使用，不会被其他地方复用，所以把它定义为静态嵌套类
🌼 博主认为除法运行的时候第二个参数若为零的话会非常严重，所以把 DivideException 定义为了检查型异常

/\*\*
 \* @author 庆医
 \* @describe 简单计算器（用于测试断言类、静态嵌套类、自定义异常）
 \*/
public class SimpleCalculator {
    private static int sum(int n1, int n2) {
        return n1 + n2;
    }

    private static double divide(double n1, double n2) throws DivideException {
        if (n2 == 0) throw new DivideException();
        return n1 / n2;
    }

    static class DivideException extends Exception {
        DivideException() {
            super("进行除法运算的时候, 第二个参不能为零");
        }
    }
}

🌼 如何测试上面的代码的正确性？
🌼 您可能会像下面的代码一样，调用方法并查看计算结果进行测试
🌼 这种测试方式是比较耗时和不高效的
🌼 业内比较专业的测试方式是：使用断言类
🌼 调用断言类中的方法，并输入您预期的结果作为参数。假如符合预期的结果，不会抛异常，代码继续往下走；如果不符合预期的结果，抛异常
🌼 下面就来写一个断言类【Asserts】

public class TestDemo {
    public static void main(String[] args) {
        // result is 7
        System.out.println("result is " + SimpleCalculator.sum(2, 5));
        try {
            double divResult = SimpleCalculator.divide(10, 2);
            // result is 5.0
            System.out.println("result is " + divResult);
        } catch (SimpleCalculator.DivideException e) {
            e.printStackTrace();
        }
    }
}

(1) 版本1

断言类实现：

/\*\*
 \* @author 庆医
 \* @describe 断言类
 \*/
public class Asserts {
    /\*\*
 \* @param expression 预期结果表达式
 \*/
    public static void check(boolean expression) {
        if (expression) return;

        try {
            throw new Exception("测试未通过");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试断言类：

/\*\*
\* @author 庆医
\* @describe 测试断言类
\*/
public class TestDemo {
   public static void main(String[] args) {
       Asserts.check(SimpleCalculator.sum(2, 5) == 7);

       // 抛异常：测试未通过
       Asserts.check(SimpleCalculator.sum(2, 5) == 10);

       try {
           // 抛异常：测试未通过
           Asserts.check(SimpleCalculator.divide(10, 2) == 20);
       } catch (SimpleCalculator.DivideException e) {
           e.printStackTrace();
       }
   }
}

在这里插入图片描述

🌼 好好琢磨一下代码，如果您看不懂，说明您前面的内容没有看明白！

(2) 版本2

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

 // 抛异常：测试未通过
   Asserts.check(SimpleCalculator.sum(2, 5) == 10);

   try {
       // 抛异常：测试未通过
       Asserts.check(SimpleCalculator.divide(10, 2) == 20);
   } catch (SimpleCalculator.DivideException e) {
       e.printStackTrace();
   }

}
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/cada95b506b94276ae82955c9592608f.png)



> 
> 🌼 好好琢磨一下代码，如果您看不懂，说明您前面的内容没有看明白！
> 
> 
> 




---


### (2) 版本2



[外链图片转存中...(img-PYB8xEHB-1715666255865)]
[外链图片转存中...(img-jUyBokq1-1715666255866)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84181986
关注
  • 13
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值