Class字节码内容学习

最新推荐文章于 2022-07-28 13:42:17 发布
最新推荐文章于 2022-07-28 13:42:17 发布
阅读量963 收藏
点赞数
分类专栏： Java 文章标签： class 字节码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nieyanshun_me/article/details/50281299
版权

今天看了一下class文件的字节码内容，做个记录。先看下java的文件：

class TestClass{
	private int m;
	public static int lala = 2;
	public int inc(){
		return m+1;
		}

	}
class SubClass extends TestClass{
	private int b=0;
	private TestClass sub= null;
public int test(){
	int cc = 0;
	return cc;
}

}

将此文件javac编译，得到两个class文件，这里说下要用的工具：winhex十六进制工具 以及javap

简单的说下class文件结构。

class文件的前四位是固定的，称为魔数，CAFEBABE（咖啡宝贝），后面3位是主版本号，主版本号之后两位是次版本号。下一位是常量池容量。然后后面很长的内容都是常量池数据，常量池之后是code字节码数据。我们就不看十六进制数据了，直接看下javap为我们计算得到的class信息。

Classfile /C:/Users/nys/Desktop/TestClass.class
  Last modified 2015-12-13; size 354 bytes
  MD5 checksum fc317f27d60bc2718a828e8834854fe2
  Compiled from "TestClass.java"
class TestClass
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#18         // java/lang/Object."<init>":()V
   #2 = Fieldref           #4.#19         // TestClass.m:I
   #3 = Fieldref           #4.#20         // TestClass.lala:I
   #4 = Class              #21            // TestClass
   #5 = Class              #22            // java/lang/Object
   #6 = Utf8               m
   #7 = Utf8               I
   #8 = Utf8               lala
   #9 = Utf8               <init>
  #10 = Utf8               ()V
  #11 = Utf8               Code
  #12 = Utf8               LineNumberTable
  #13 = Utf8               inc
  #14 = Utf8               ()I
  #15 = Utf8               <clinit>
  #16 = Utf8               SourceFile
  #17 = Utf8               TestClass.java
  #18 = NameAndType        #9:#10         // "<init>":()V
  #19 = NameAndType        #6:#7          // m:I
  #20 = NameAndType        #8:#7          // lala:I
  #21 = Utf8               TestClass
  #22 = Utf8               java/lang/Object
{
  public static int lala;
    descriptor: I
    flags: ACC_PUBLIC, ACC_STATIC

  TestClass();
    descriptor: ()V
    flags:
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0

  public int inc();
    descriptor: ()I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: getfield      #2                  // Field m:I
         4: iconst_1
         5: iadd
         6: ireturn
      LineNumberTable:
        line 5: 0

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: iconst_2
         1: putstatic     #3                  // Field lala:I
         4: return
      LineNumberTable:
        line 3: 0
}
SourceFile: "TestClass.java"
这是TestClass的class文件，我们看到主次版本号之后，有一个constant pool常量池，看下常量池内容。可以看到常量池的第一项是方法表（class文件由两部分组成，一是无回复无符号数，u1 u2 u4 u8,二是表，表是由多个无符号数和其它表构成的数据项，class文件本身就是一张表结构），指向偏移量#5.#18，我们往下可以看到#5是一个class表，指向#22，而#22就是java/lang/object，继续看下#18，可以看到是init<>f方法，所以我们可知，第一个methodref是object的init<>方法，后面的以此类推。下面是SubClass的文件内容
class SubClass extends TestClass
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#18         // TestClass."<init>":()V
   #2 = Fieldref           #4.#19         // SubClass.b:I
   #3 = Fieldref           #4.#20         // SubClass.sub:LSubClass;
   #4 = Class              #21            // SubClass
   #5 = Class              #22            // TestClass
   #6 = Utf8               b
   #7 = Utf8               I
   #8 = Utf8               sub
   #9 = Utf8               LSubClass;
  #10 = Utf8               <init>
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               test
  #15 = Utf8               ()I
  #16 = Utf8               SourceFile
  #17 = Utf8               TestClass.java
  #18 = NameAndType        #10:#11        // "<init>":()V
  #19 = NameAndType        #6:#7          // b:I
  #20 = NameAndType        #8:#9          // sub:LSubClass;
  #21 = Utf8               SubClass
  #22 = Utf8               TestClass
{
  SubClass();
    descriptor: ()V
    flags:
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method TestClass."<init>":()V
         4: aload_0
         5: iconst_0
         6: putfield      #2                  // Field b:I
         9: aload_0
        10: aconst_null
        11: putfield      #3                  // Field sub:LSubClass;
        14: return
      LineNumberTable:
        line 9: 0
        line 10: 4
        line 11: 9

  public int test();
    descriptor: ()I
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=1
         0: iconst_0
         1: istore_1
         2: iload_1
         3: ireturn
      LineNumberTable:
        line 13: 0
        line 14: 2
}
SourceFile: "TestClass.java"

对比一下，第一个为MethodRef，指向初始化int方法，后面是类自身的Fieldref，再往后面就是一个class表，偏移量是指向的自身class的描述表信息，后面紧跟一个class表，指向其父类。同时可以看到父类中private  int m;以及public static int lala = 2;，在子类的常量池中并没有相应的Filedref表，由此可知，子类继承父类的时候，其父类的method和filed是不会写入子类的常量池的。我们修改一下SubClass的内容。 
class SubClass extends TestClass {

	private int b = 0;

	public TestClass sub = new SubClass();

	public int test() {
		System.out.println("b");
		int cc = 0;
		return cc;
	}

	public void println() {
		Map map = new HashMap();
		map.put("","");
		sub.test();
	}

}
然后编译，看下class文件内容： 
<div>Classfile /C:/Users/nys/Desktop/SubClass.class
  Last modified 2015-12-13; size 698 bytes
  MD5 checksum bac3236b7989742ba907bf359a9ac30b
  Compiled from "TestClass.java"
class SubClass extends TestClass
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Methodref          #14.#28        // TestClass."<init>":()V
   #2 = Fieldref           #3.#29         // SubClass.b:I
   #3 = Class              #30            // SubClass
   #4 = Methodref          #3.#28         // SubClass."<init>":()V
   #5 = Fieldref           #3.#31         // SubClass.sub:LTestClass;
   #6 = Fieldref           #32.#33        // java/lang/System.out:Ljava/io/PrintStream;
   #7 = String             #15            // b
   #8 = Methodref          #34.#35        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #9 = Class              #36            // java/util/HashMap
  #10 = Methodref          #9.#28         // java/util/HashMap."<init>":()V
  #11 = String             #37            //
  #12 = InterfaceMethodref #38.#39        // java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  #13 = Methodref          #14.#40        // TestClass.test:()I
  #14 = Class              #41            // TestClass
  #15 = Utf8               b
  #16 = Utf8               I
  #17 = Utf8               sub
  #18 = Utf8               LTestClass;
  #19 = Utf8               <init>
  #20 = Utf8               ()V
  #21 = Utf8               Code
  #22 = Utf8               LineNumberTable
  #23 = Utf8               test
  #24 = Utf8               ()I
  #25 = Utf8               println
  #26 = Utf8               SourceFile
  #27 = Utf8               TestClass.java
  #28 = NameAndType        #19:#20        // "<init>":()V
  #29 = NameAndType        #15:#16        // b:I
  #30 = Utf8               SubClass
  #31 = NameAndType        #17:#18        // sub:LTestClass;
  #32 = Class              #42            // java/lang/System
  #33 = NameAndType        #43:#44        // out:Ljava/io/PrintStream;
  #34 = Class              #45            // java/io/PrintStream
  #35 = NameAndType        #25:#46        // println:(Ljava/lang/String;)V
  #36 = Utf8               java/util/HashMap
  #37 = Utf8
  #38 = Class              #47            // java/util/Map
  #39 = NameAndType        #48:#49        // put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  #40 = NameAndType        #23:#24        // test:()I
  #41 = Utf8               TestClass
  #42 = Utf8               java/lang/System
  #43 = Utf8               out
  #44 = Utf8               Ljava/io/PrintStream;
  #45 = Utf8               java/io/PrintStream
  #46 = Utf8               (Ljava/lang/String;)V
  #47 = Utf8               java/util/Map
  #48 = Utf8               put
  #49 = Utf8               (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
{
  public TestClass sub;
    descriptor: LTestClass;
    flags: ACC_PUBLIC</div><div>
</div><div>  SubClass();
    descriptor: ()V
    flags:
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method TestClass."<init>":()V
         4: aload_0
         5: iconst_0
         6: putfield      #2                  // Field b:I
         9: aload_0
        10: new           #3                  // class SubClass
        13: dup
        14: invokespecial #4                  // Method "<init>":()V
        17: putfield      #5                  // Field sub:LTestClass;
        20: return
      LineNumberTable:
        line 20: 0
        line 22: 4
        line 24: 9</div><div>
</div><div>  public int test();
    descriptor: ()I
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=1
         0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #7                  // String b
         5: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: iconst_0
         9: istore_1
        10: iload_1
        11: ireturn
      LineNumberTable:
        line 27: 0
        line 28: 8
        line 29: 10</div><div>
</div><div>  public void println();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=2, args_size=1
         0: new           #9                  // class java/util/HashMap
         3: dup
         4: invokespecial #10                 // Method java/util/HashMap."<init>":()V
         7: astore_1
         8: aload_1
         9: ldc           #11                 // String
        11: ldc           #11                 // String
        13: invokeinterface #12,  3           // InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
        18: pop
        19: aload_0
        20: getfield      #5                  // Field sub:LTestClass;
        23: invokevirtual #13                 // Method TestClass.test:()I
        26: pop
        27: return
      LineNumberTable:
        line 33: 0
        line 34: 8
        line 37: 19
        line 38: 27
}
SourceFile: "TestClass.java"</div>


可以看到，我们在方法里new的HashMap。会在常量池里有所体现，
   #9 = Class              #34            // java/util/HashMap
  #10 = Methodref          #9.#26         // java/util/HashMap."<init>":()V
  #12 = InterfaceMethodref #38.#39        // java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
由此可知，在编译生成class文件时，也会将方法内部的类方法调用等信息放在常量池中形成表数据，在运行时确定直接引用（符号引用-->直接引用）。
我们看下code字节码的内容，注意看下map.put("","");这几生成的指令，如下：
       13: invokeinterface #12,  3           // InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
可以看到，这里调用的是invokeinterface指令，这里就是动态链接，运行时确定具体内存地址的方法。
另外，虚拟机的加载存储指令，用于将数据在栈帧中的局部变量表和操作数栈之间来回传输，load型号指令用于局部变量加载到操作数栈，store指令用于将数据从操作数栈存储到局部变量表。
注：locals参数是局部变量表的最大容量，单位Slot。局部变量表位于栈帧内，大小在编译器就已确定（比如locals参数），而栈帧中存放了局部变量表 操作数栈 动态连接 返回地址等信息。Slot中可存放 boolean byte char short int float reference 和returnAddress8种类型。其中reference是引用类型，此引用可以直接或间接的找到的内存地址，以及对象在方法区的class数据。局部变量表对Slot使索引定位的方式 进行管理，下表从0开始，0为存储this引用，剩下Slot按照形参顺序，从一开始进行分配，形参分配Slot后，在对方法内部参数进行Slot分配。Slot是可重用对。其字节大小并没有 明确对说明，可以存放32位以数据，而龙double需要使用两个Slot.Slot的复用回对gc产生影响，如果一个方法后面执行对时间较长，而前面又new 了大量对内存空间，此时这些内存不会被回收（如果这些Slot被复用了，那么堆区对内存就可回收，引用已不存在）。所以在不确定Slot是否会被后面变量复用对时候，最好手动置为null。
每个栈帧都包含一个指向运行时常量池中该栈帧锁属方法对引用，持有这个引用是为了支持方法调用过程中对动态链接。


nieyanshun_me
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Class（字节码)了解基础
12-16
简单了解字节码，便于以后深入学习，简单了解字节码，便于以后深入学习
Class字节码文件结构总结
weixiaohuai的博客
08-15 818
目录 一、什么是字节码指令 二、解读字节码指令的方式 三、Class字节码文件结构 四、魔数：Class文件的标志 五、Class文件的版本号 六、常量池：存放所有常量 七、访问标识（access_flag） 八、类索引、父类索引、接口索引集合 九、字段表集合 十、方法表集合 十一、属性表集合 十二、总结 一、什么是字节码指令 Java源代码经过编译器编译（javac）之后便会生成一个字节码文件，字节码是一种二进制的类文件，它的内容是JVM的指令，而不像C、C++经由编译器直接生
Java进阶——如何查看Java字节码
m0_67401382的博客
07-28 876
深入学习Java语言，也免不了要去研究JVM类加载、JVM字节码相关的东西，这时就需要经常查看字节码。
带你分析字节码-深入理解class（一）
qq_28589239的博客
12-01 6174
class文件是编译器编译之后供虚拟机解释执行的二进制字节码文件，不只是java，只要是满足java虚拟机规范，其他的语言也可以编译成class文件供虚拟机执行，比如groovy，Groovy，JRuby，FANTOM，Jython，和Scala。这是在jvm上运行的5大脚本语言。下面就带你分析一个class的字节码文件，class文件只有无符号数和表两种基本的数据类型，u1，u2，u4，u8代表1
类的class字节码文件，学这一篇就够了
cnsddsnc的博客
10-16 840
涉及知识点： 符号引用和直接引用 https://blog.csdn.net/qq_34402394/article/details/72793119?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1 JVM指令集 编写一个类：HelloW.
通过一个.class文件探究java的字节码文件结构
lhever_的博客
04-16 6188
在写本文之前，本人对java字节码文件结构只是有一个大致的了解然而，有一天我突然想要细致的研究一下class文件的内部结构，于是我就真这么做了，最终的后果是浪费了周六和周天的大好时光，才将一个及其简单的类的class文件给手工翻译成字节码今天的博客目的就是把我一个字节一个字节的翻译那个class文件的过程粘贴出来，希望对某些想要了解java字节码结构的人有用，注意：我只是简单的翻译了一下，其中涉及的
基于Class字节码透视java动态代理本质
08-31
基于Class字节码透视java动态代理本质
基于Class字节码透视java动态代理本质(4)
08-31
基于Class字节码透视java动态代理本质(4)
LengendOfDong#Blog#mac下查看Class文件字节码1
07-25
mac下查看Class文件字节码1.使用vi命令的方式vi -b 文件名进入后输入支持鼠标选中高亮，很好用，用来学习Java字节码很实用。
基于Class字节码透视java动态代理本质(1)
08-31
基于Class字节码透视java动态代理本质(1)
Java 不同类型属性在字节码文件class中
shuiqi2000的专栏
08-23 480
Object Attribute Souce code public class ObjectAttribute {     public int intValue = 0;         public String stringValue = "testString" ;         public Integer integerValue = 0; }
深入理解JVM之Java字节码（.class）文件详解
Windy的专栏
01-04 3万+
Understanding bytecode makes you a better programmer 前言 作为一个Java开发者，对技术的追求而不仅仅停留在会用API，会写基本功能上，要想在技术上有更高的造诣，就需要深入到原理层面去认识代码运行的机制。因此，本文从class字节码文件的结构入手，一步步来解剖二进制字节码的内部工作原理，这对深入理解JVM的运行机制大有裨益，同时，对于想要使
Java字节码.class文件案例分析
风中的索莉逖亚
01-12 8924
我是个懒人，平时都不太喜欢写点东西，大部分时间都是自己一个人在琢磨，被同事给了个外号叫：“码疯”；很少泡在CSDN的Blog中，也只是偶尔想起来了写点东西过来玩玩，大部分时间都习惯了一个人享受午后阳光下的阅卷、享受半夜灯光中的码战。慢慢地反而习惯了一种生活，让自己心里得激情沉浸在无忧无虑的生活中，大部分时间则是真正在享受代码带来的生活的快感。这篇东西是周末忙里偷闲用Markdown整理的，记录下来分享给大家，希望有所价值。
从一个class文件深入理解Java字节码结构
热门推荐
四月葡萄的博客
05-15 3万+
前言 我们都知道，Java程序最终是转换成class文件执行在虚拟机上的，那么class文件是个怎样的结构，虚拟机又是如何处理去执行class文件里面的内容呢，这篇文章带你深入理解Java字节码中的结构。 1.Demo源码 首先，编写一个简单的Java源码： package com.april.test; public class Demo { private int n...
class字节码类结构
Fuego801的博客
01-09 428
解析class文件： 一般先将class字节码从内存中读取出来， 然后再分别根据读取到的字节码翻译为对应的信息，而各种名称需要从常量池中获取对应的字符串。
class字节计算
TBViwer
08-28 1019
1、类的大小类的sizeof()大小一般是类中的所有成员的sizeof()大小之和，这个就不用多说。确切的说，用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小。注意：类只是一个类型定义，它本身是没有大小可言的。对象大小= vptr(类中定义了多个virtual函数，仍然为占用4个字节) + 所有非静态数据成员大小 + Aligin字节大小（依赖于不同的编译器）。
深入理解class字节码中的<init>,<clinit>
vikenpeng的专栏
11-17 1454
        java中有两种特殊的方法&lt;init&gt;,&lt;clinit&gt;  1,当java类中，存在用static修饰的静态类型字段，或static块，编译器便会生成&lt;clinit&gt; 2,当java类中定义了构造方法，或其他非static类成员变量被赋了初始值，编译器便会生成&lt;init&gt; 代码 public class Test{     ...
C++中类对象的内存布局和占用空间
mmdev
04-14 385
很多C++书籍中都介绍过，一个Class对象需要占用多大的内存空间。最权威的结论是： *非静态成员变量总合。 *加上编译器为了CPU计算，作出的数据对齐处理。 *加上为了支持虚函数，产生的额外负担。 介绍完了理论知识后，再看看再找一个例子看看（注：一下所有结果都是在VC6.0 开发环境中得出的结论） 一、空类的Size class Car { }; void main()...
命令查看java的class字节码文件
Loger
07-15 3万+
查看java字节码  1 javac –verbose查看运行类是加载了那些jar文件 HelloWorld演示： javac –verbose HelloWorld.java 可以看到虚拟机编译时做了那些事情…… java –verbose HelloWorld 可以看到虚拟机运行一个程序时加载的jar包 更多内容查看javac –help命令
androidStudio 修改 字节码
最新发布
05-25
在 Android Studio 中修改字节码需要使用字节码操作库，例如 ASM (Java 字节码操作框架)。 以下是基本的步骤： ...如果您不熟悉字节码操作和 Java 虚拟机的工作原理，请先进行充分的学习和测试。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值