Java 深入理解异常处理机制

最新推荐文章于 2023-12-03 19:34:33 发布
最新推荐文章于 2023-12-03 19:34:33 发布
阅读量451 收藏
点赞数 1
分类专栏： Java 基础 文章标签： java 异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shipsail/article/details/121877583
版权

异常处理

本文从字节码角度出发，分析Java异常处理机制。

try-finally

package com.one.exception;
public class TryCatchFinally {
    public static void main(String[] args) {
        try {
            System.out.println("try");
        }finally {
            System.out.println("finally");
        }
    }
}

 // try 部分
 0 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
 3 ldc #3 <try>
 5 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>

 // 正常执行
 // finally 部分
	 8 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
	11 ldc #5 <finally>
	13 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
// 正常退出
16 goto 30 (+14)

// 异常跳转到此处
// finally 部分
19 astore_1
	20 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
	23 ldc #5 <finally>
	25 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
28 aload_1
29 athrow
30 return

在这里插入图片描述

try代码块会记录在异常表中，可以看到上述代码中无论是否报错都会执行finally代码块，编译器为正常、异常的情况都编译了finally代码块，通过比较可以发现多了astore_1、aload_1、athrow等指令，在下文中做出解释。

package com.one.exception;
public class TryCatchFinally {
    public static void main(String[] args) {
        try {
            System.out.println("try");
            int a = 1/0;
        }finally {
            System.out.println("finally");
        }
    }
}
/*
try
finally
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.one.exception.TryCatchFinally.main(TryCatchFinally.java:6)
*/

通过测试可以知道尽管我们没有捕捉到try代码块中的异常，但程序仍然执行了finally代码块。

这么设计是为了开发人员可以在finally中进行资源释放，如数据库连接、锁资源、网络连接等，避免产生死锁。

try-catch-finally

为测试代码加入catch代码块

package com.one.exception;
public class TryCatchFinally2 {
    public static void main(String[] args) {
        try {
            System.out.println("try");
        }catch (Exception e){
            System.out.println("catch");
        }
        finally {
            System.out.println("finally");
        }
    }
}

// try 代码块
 0 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
 3 ldc #3 <try>
 5 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
// finally 代码块
 8 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
11 ldc #5 <finally>
13 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
// 正常退出
16 goto 50 (+34)


// 异常捕获1
19 astore_1
	// catch 代码块
	20 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
	23 ldc #7 <catch>
	25 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
	// finnaly 代码块
	28 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
	31 ldc #5 <finally>
	33 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
// 捕获成功后正常退出
36 goto 50 (+14)

// 异常捕获2
39 astore_2
	// finally 代码块
	40 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
	43 ldc #5 <finally>
	45 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
// 向外抛出异常
48 aload_2
49 athrow
50 return

在这里插入图片描述
首先对比前两个异常处理的相同之处和不同之处

  • 起始PC相同（try 代码块开始）
  • 结束PC相同（try 代码块结束）
  • 跳转PC不同，第一个异常处理跳转到我们定义的catch代码块，第二个异常处理跳转到PC = 39
  • 捕获类型不同，一个异常处理捕获Exception，第二个异常处理捕Any

由此可以知道如果在try代码块中发生了Exception类型的异常，则跳转到我们定义的异常捕获中，如果在try代码块中发生了非Exception类型的异常，则跳转到PC = 39

再看第三个异常处理

  • 起始PC（catch 代码块开始）
  • 结束PC（catch 代码块结束）
  • 跳转PC = 39

表示如果在catch代码块中出现了异常，则跳转到PC = 39 处

最后来看PC = 39 到底做了什么？

39 astore_2
	// finally 代码块
	40 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
	43 ldc #5 <finally>
	45 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
// 向外抛出异常
48 aload_2
49 athrow

很明显运行了finally的代码块，并且通过athrow向外抛出了异常。

throw

在try代码块中加入一句throw

package com.one.exception;
public class TryCatchFinally3 {
    public static void main(String[] args) throws Exception {
        try {
            System.out.println("try");
            throw new Exception();
        }catch (Exception e){
            System.out.println("catch");
        }
        finally {
            System.out.println("finally");
        }
    }
}

 0 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
 3 ldc #3 <try>
 5 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
 	//主动抛出异常
	 8 new #5 <java/lang/RuntimeException>
	11 dup
	12 invokespecial #6 <java/lang/RuntimeException.<init> : ()V>
	15 athrow
16 astore_1
17 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
20 ldc #8 <catch>
22 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
25 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
28 ldc #9 <finally>
30 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
33 goto 47 (+14)
36 astore_2
37 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
40 ldc #9 <finally>
42 invokevirtual #4 <java/io/PrintStream.println : (Ljava/lang/String;)V>
45 aload_2
46 athrow
47 return

athrow

JVM 官方解释

在这里插入图片描述
大概就是会获取一个Throwable的异常对象，如果是NULL就抛出空指针异常，并且如果涉及到同步块，会处理monitor

finally-with-resource

package com.one.exception;

import java.io.Closeable;
import java.io.IOException;
import java.util.Scanner;

public class TryWithResource implements Closeable {

    public static void main(String[] args) {
        try(TryWithResource tryWithResource = new TryWithResource()){
            System.out.println("try");
        }catch (Exception e){
            System.out.println("catch");
        }finally {
            System.out.println("finally");
        }
    }

    @Override
    public void close() throws IOException {
        System.out.println("close");
    }
}


  0 new #2 <com/one/exception/TryWithResource>
  3 dup
  4 invokespecial #3 <com/one/exception/TryWithResource.<init> : ()V>
  7 astore_1
  8 aconst_null
  9 astore_2
 10 getstatic #4 <java/lang/System.out : Ljava/io/PrintStream;>
 13 ldc #5 <try>
 15 invokevirtual #6 <java/io/PrintStream.println : (Ljava/lang/String;)V>
 18 aload_1
 19 ifnull 89 (+70)
 22 aload_2
 23 ifnull 42 (+19)
 26 aload_1
 27 invokevirtual #7 <com/one/exception/TryWithResource.close : ()V>
 30 goto 89 (+59)
 33 astore_3
 34 aload_2
 35 aload_3
 36 invokevirtual #9 <java/lang/Throwable.addSuppressed : (Ljava/lang/Throwable;)V>
 39 goto 89 (+50)
 42 aload_1
 43 invokevirtual #7 <com/one/exception/TryWithResource.close : ()V>
 46 goto 89 (+43)
 49 astore_3
 50 aload_3
 51 astore_2
 52 aload_3
 53 athrow
 54 astore 4
 56 aload_1
 57 ifnull 86 (+29)
 60 aload_2
 61 ifnull 82 (+21)
 64 aload_1
 65 invokevirtual #7 <com/one/exception/TryWithResource.close : ()V>
 68 goto 86 (+18)
 71 astore 5
 73 aload_2
 74 aload 5
 76 invokevirtual #9 <java/lang/Throwable.addSuppressed : (Ljava/lang/Throwable;)V>
 79 goto 86 (+7)
 82 aload_1
 83 invokevirtual #7 <com/one/exception/TryWithResource.close : ()V>
 86 aload 4
 88 athrow
 89 getstatic #4 <java/lang/System.out : Ljava/io/PrintStream;>
 92 ldc #10 <finally>
 94 invokevirtual #6 <java/io/PrintStream.println : (Ljava/lang/String;)V>
 97 goto 133 (+36)
100 astore_1
101 getstatic #4 <java/lang/System.out : Ljava/io/PrintStream;>
104 ldc #12 <catch>
106 invokevirtual #6 <java/io/PrintStream.println : (Ljava/lang/String;)V>
109 getstatic #4 <java/lang/System.out : Ljava/io/PrintStream;>
112 ldc #10 <finally>
114 invokevirtual #6 <java/io/PrintStream.println : (Ljava/lang/String;)V>
117 goto 133 (+16)
120 astore 6
122 getstatic #4 <java/lang/System.out : Ljava/io/PrintStream;>
125 ldc #10 <finally>
127 invokevirtual #6 <java/io/PrintStream.println : (Ljava/lang/String;)V>
130 aload 6
132 athrow
133 return

指令变得复杂，异常表也变得复杂，但可以清楚关于try-with-resource的几个特点：

  • 是 new 一个对象，而不是使用已有得对象（适用于临时打开的资源）
  • 编译器在编译过程中自动加入了close的调用，所以不需要手动调用
  • 可以实现自动控制多个Closeable接口的资源对象的close

总结

  1. 遇到异常在异常表中按顺序匹配异常
  2. 编译器在异常表中隐式设置异常捕获cp_info #0，捕获try语句块、catch语句块，并通过athrow抛出
  3. try代码块、catch代码块出现异常时，在最后一定会执行finally代码块
  4. finally代码块中出现异常，只能向外抛出
  5. 可以使用try-with-resource简化资源对象的使用
TiggerRun
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解java异常处理机制
请叫我搞向
10-29 407
1. 引子try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。package Test; public cl
Java 深入理解Java异常以及异常处理机制
WYSCODER的博客
11-18 1068
文章目录异常1.异常的定义2.异常的三种类型2.1编译期异常2.2运行期异常2.3错误3.异常的继承关系4.Java异常处理机制异常处理机制关键字5.异常处理示例5.1异常的捕获5.1.1 try catch finally5.1.2 注意事项5.2抛异常5.2.1throw5.2.2throws6.用户自定义异常 异常 1.异常的定义 异常就是有异于常态，和正常情况不一样，有错误出错。在Java中，阻止当前方法或作用域的情况，称之为异常。 发生异常的原因有很多，这些异常有的是因为用户错误引起，有的是程序错
深入理解java异常处理机制Java开发Java经验技巧共
11-22
这篇19页的PDF文档《深入理解java异常处理机制Java开发Java经验技巧共》可能涵盖了Java异常处理的基本概念、最佳实践以及高级用法。在Java中，异常处理通过五个关键字来实现：try、catch、finally、throw和throws。 ...
深入理解java异常处理机制及应用
08-31
Java异常处理机制是Java编程中不可或缺的一部分，它提供了一种有序的方式来处理程序运行时可能出现的错误情况。在Java中，异常是一种特殊的对象，用于表示程序运行时的不正常状态。异常处理通过五个关键字来实现：`...
深入理解java异常处理机制的原理和开发应用
08-30
本文将深入探讨Java异常处理的关键概念、原则和最佳实践。 首先，Java异常处理涉及五个核心关键字：try、catch、finally、throw和throws。try块用于包含可能会抛出异常的代码，catch块捕获并处理特定类型的异常，...
深入理解Java编程中异常处理的优劣
09-05
Java编程中的异常处理是保证程序健壮性与稳定性的关键环节。本文主要探讨了Java异常处理的优缺点，包括对不同类型的异常分类、处理...通过深入了解异常处理的机制和最佳实践，可以显著提升Java程序的稳定性和维护性。
Java：详解Java中的异常(Error与Exception)
Dream It Possible
01-31 2449
一、 异常机制的概述 异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。 程序错误分为三种：1.编译错误；2.运行时错误；3.逻辑错误。 （1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是大家在刚接触编程语言最常遇到的问题。 （2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。 ...
2020-11-08
weixin_39743450的博客
11-08 866
Java：详解Java中的异常(Error与Exception) 置顶王小二(IT)2018-06-22 16:54:2666242收藏389 分类专栏：编程语言(Java基础)文章标签：trycatchfinallyError 版权 《Java：详解Java中的异常(Error与Exception)》 《Java：简述Java中的自定义异常》 《Java：简述throw-throws异常抛出》 《Java：简述try-catch-finally异常捕获》 《J...
java astore_JVM指令手册
weixin_36294852的博客
02-16 2243
注：建议直接复制保存至本地，研究jvm运行，执行指令非常有帮助一、未归类系列A此系列暂未归类。指令码 助记符 说明0x00 nop 什么都不做0x01 aconst_null 将null推送至栈顶二、const系列该系列命令主要负责把简单的数值类型送到栈顶。该系列命令不带参数。注意只把简单的数值类型送到栈顶时，才使用如下的命令。比如对应int型才该方式只能把-1,0,1,2,3,4,5(分别采用i...
详解JVM字节码指令
最新发布
点点关注不迷路
12-03 427
详解JVM字节码指令
java操作字节码_使用javap分析Java字节码的一个例子
weixin_39738416的博客
02-12 90
I have the following source code in Java:class Outer {Nested nested;Nested getNested() {return nested;}}class Nested {Inner inner;Inner getInner() {return inner;}}class Inner {String foo;String getFoo...
java astore_java synchronize - 线程同步机制
weixin_39804523的博客
02-13 151
Java支持同步机制的是Monitor。Monitor就像是拥有一个特殊房间的建筑，在同一时间里，这间特殊的房间只能被一个线程拥有。enter the monitor:进入这幢建筑acquiring the monitor:进入建筑里的特殊房间owning the monitor:拥有特殊房间的所有权releasing the monitor:离开特殊的房间exiting the monitor:...
Java字节码详解（二）字节码的运行过程
a15089415104的博客
10-23 1万+
文章目录JVM的一些基础概念JVM数据类型JVM的内存结构 前一章讲述了java字节码文件的生成以及字节码文件中各个字段代表的含义，在本章节将讲述字节码是什么运行的 JVM的一些基础概念 要理解java字节码的运行情况，首先要了解有关JVM的一些知识，这些是java字节码运行的先决条件。 JVM数据类型 Java是静态类型的，它会影响字节码指令的设计，这样指令就会期望自己对特定类型的值进行操作...
java 对象与引用_浅谈对象与引用
weixin_42298622的博客
02-20 151
对象与引用new一个对象最简单的例子开始：new Object();简单地讲，new Object()就是创建了一个Object类型的实例(instance)，分配在了JVM的堆内存中以public方法作为示例，来看一下：PS: 无论是public方法，还是private/protected/package方法，抑或是构造方法，甚至是在静态代码块，静态变量，实例变量，对于new Object这个动...
aload、aload_1、iload都是什么意思
热门推荐
qq_27416233的博客
05-09 1万+
aload 什么意思 原文链接 http://www.importnew.com/13107.html1、aload 1、aload 从局部变量表的相应位置装载一个对象引用到操作数栈的栈顶 aload_0把this装载到了操作数栈中aload_0是一组格式为aload_的操作码中的一个，这一组操作码把对象的引用装载到操作数栈中标志了待处理的局部变量表中的位置，但取值仅可为0、1、2或者3。 2、i...
深入理解Java异常处理机制
"异常的捕获和处理是Java高级编程中的关键部分，它涉及到程序的稳定性和错误处理机制。在Java中，异常处理通过try-catch-finally结构来实现，用于处理...通过深入理解和实践，开发者能够构建高效、可靠的Java应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值