JVM类加载与字节码技术_编译期处理

最新推荐文章于 2022-05-05 08:42:53 发布
最新推荐文章于 2022-05-05 08:42:53 发布
阅读量174 收藏
点赞数
分类专栏： JVM 文章标签： 编译器 反编译 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaaaa1111111199/article/details/115169163
版权

编译期处理

所谓的 语法糖 ，其实就是指 java 编译器把 *.java 源码编译为 *.class 字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员的负担，算是 java 编译器给我们的一个额外福利

注意，以下代码的分析，借助了 javap 工具，idea 的反编译功能，idea 插件 jclasslib 等工具。另外， 编译器转换的结果直接就是 class 字节码，只是为了便于阅读，给出了 几乎等价 的 java 源码方式，并不是编译器还会转换出中间的 java 源码，切记。

默认构造函数
public class Candy1 {

}

经过编译期优化后

public class Candy1 {
   //这个无参构造器是java编译器帮我们加上的
   public Candy1() {
      //即调用父类 Object 的无参构造方法，即调用 java/lang/Object." <init>":()V
      super();
   }
}
自动拆装箱

基本类型和其包装类型的相互转换过程，称为拆装箱

在JDK 5以后，它们的转换可以在编译期自动完成

public class Demo2 {
   public static void main(String[] args) {
      Integer x = 1;
      int y = x;
   }
}

转换过程如下

public class Demo2 {
   public static void main(String[] args) {
      //基本类型赋值给包装类型，称为装箱
      Integer x = Integer.valueOf(1);
      //包装类型赋值给基本类型，称谓拆箱
      int y = x.intValue();
   }
}
泛型集合取值

泛型也是在 JDK 5 开始加入的特性，但 java 在编译泛型代码后会执行 泛型擦除 的动作，即泛型信息在编译为字节码之后就丢失了，实际的类型都当做了 Object 类型来处理：

public class Demo3 {
   public static void main(String[] args) {
      List<Integer> list = new ArrayList<>();
      list.add(10);
      Integer x = list.get(0);
   }
}

对应字节码

Code:
    stack=2, locals=3, args_size=1
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: bipush        10
      11: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      //这里进行了泛型擦除，实际调用的是add(Objcet o)
      14: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z

      19: pop
      20: aload_1
      21: iconst_0
      //这里也进行了泛型擦除，实际调用的是get(Object o)   
      22: invokeinterface #6,  2            // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
//这里进行了类型转换，将Object转换成了Integer
      27: checkcast     #7                  // class java/lang/Integer
      30: astore_2
      31: return

所以调用get函数取值时，有一个类型转换的操作

Integer x = (Integer) list.get(0);

如果要将返回结果赋值给一个int类型的变量，则还有自动拆箱的操作

int x = (Integer) list.get(0).intValue();
可变参数
public class Demo4 {
   public static void foo(String... args) {
      //将args赋值给arr，可以看出String...实际就是String[] 
      String[] arr = args;
      System.out.println(arr.length);
   }

   public static void main(String[] args) {
      foo("hello", "world");
   }
}

可变参数 String… args 其实是一个 String[] args ，从代码中的赋值语句中就可以看出来。 同 样 java 编译器会在编译期间将上述代码变换为：

public class Demo4 {
   public Demo4 {}

    
   public static void foo(String[] args) {
      String[] arr = args;
      System.out.println(arr.length);
   }

   public static void main(String[] args) {
      foo(new String[]{"hello", "world"});
   }
}

注意，如果调用的是foo()，即未传递参数时，等价代码为foo(new String[]{})，创建了一个空数组，而不是直接传递的null

foreach
public class Demo5 {
	public static void main(String[] args) {
        //数组赋初值的简化写法也是一种语法糖。
		int[] arr = {1, 2, 3, 4, 5};
		for(int x : arr) {
			System.out.println(x);
		}
	}
}

编译器会帮我们转换为

public class Demo5 {
    public Demo5 {}

	public static void main(String[] args) {
		int[] arr = new int[]{1, 2, 3, 4, 5};
		for(int i=0; i<arr.length; ++i) {
			int x = arr[i];
			System.out.println(x);
		}
	}
}

如果是集合使用foreach

public class Demo5 {
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
      for (Integer x : list) {
         System.out.println(x);
      }
   }
}

集合要使用foreach，需要该集合类实现了Iterable接口，因为集合的遍历需要用到迭代器Iterator

public class Demo5 {
    public Demo5 {}
    
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
      //获得该集合的迭代器
      Iterator<Integer> iterator = list.iterator();
      while(iterator.hasNext()) {
         Integer x = iterator.next();
         System.out.println(x);
      }
   }
}
switch字符串
public class Demo6 {
   public static void main(String[] args) {
      String str = "hello";
      switch (str) {
         case "hello" :
            System.out.println("h");
            break;
         case "world" :
            System.out.println("w");
            break;
         default:
            break;
      }
   }
}

在编译器中执行的操作

public class Demo6 {
   public Demo6() {
      
   }
   public static void main(String[] args) {
      String str = "hello";
      int x = -1;
      //通过字符串的hashCode+value来判断是否匹配
      switch (str.hashCode()) {
         //hello的hashCode
         case 99162322 :
            //再次比较，因为字符串的hashCode有可能相等
            if(str.equals("hello")) {
               x = 0;
            }
            break;
         //world的hashCode
         case 11331880 :
            if(str.equals("world")) {
               x = 1;
            }
            break;
         default:
            break;
      }

      //用第二个switch在进行输出判断
      switch (x) {
         case 0:
            System.out.println("h");
            break;
         case 1:
            System.out.println("w");
            break;
         default:
            break;
      }
   }
}

过程说明：

  • 在编译期间，单个的switch被分为了两个
    • 第一个用来匹配字符串，并给x赋值
      • 字符串的匹配用到了字符串的hashCode，还用到了equals方法
      • 使用hashCode是为了提高比较效率，使用equals是防止有hashCode冲突（如BM和C.）
    • 第二个用来根据x的值来决定输出语句
switch枚举
public class Demo7 {
   public static void main(String[] args) {
      SEX sex = SEX.MALE;
      switch (sex) {
         case MALE:
            System.out.println("man");
            break;
         case FEMALE:
            System.out.println("woman");
            break;
         default:
            break;
      }
   }
}

enum SEX {
   MALE, FEMALE;
}

编译器中执行的代码如下

public class Demo7 {
   /**     
    * 定义一个合成类（仅 jvm 使用，对我们不可见）     
    * 用来映射枚举的 ordinal 与数组元素的关系     
    * 枚举的 ordinal 表示枚举对象的序号，从 0 开始     
    * 即 MALE 的 ordinal()=0，FEMALE 的 ordinal()=1     
    */ 
   static class $MAP {
      //数组大小即为枚举元素个数，里面存放了case用于比较的数字
      static int[] map = new int[2];
      static {
         //ordinal即枚举元素对应所在的位置，MALE为0，FEMALE为1
         map[SEX.MALE.ordinal()] = 1;
         map[SEX.FEMALE.ordinal()] = 2;
      }
   }

   public static void main(String[] args) {
      SEX sex = SEX.MALE;
      //将对应位置枚举元素的值赋给x，用于case操作
      int x = $MAP.map[sex.ordinal()];
      switch (x) {
         case 1:
            System.out.println("man");
            break;
         case 2:
            System.out.println("woman");
            break;
         default:
            break;
      }
   }
}

enum SEX {
   MALE, FEMALE;
}
枚举类
enum SEX {
   MALE, FEMALE;
}

转换后的代码

public final class Sex extends Enum<Sex> {   
   //对应枚举类中的元素
   public static final Sex MALE;    
   public static final Sex FEMALE;    
   private static final Sex[] $VALUES;
   
    static {       
    	//调用构造函数，传入枚举元素的值及ordinal
    	MALE = new Sex("MALE", 0);    
        FEMALE = new Sex("FEMALE", 1);   
        $VALUES = new Sex[]{MALE, FEMALE}; 
   }
 	
   //调用父类中的方法
    private Sex(String name, int ordinal) {     
        super(name, ordinal);    
    }
   
    public static Sex[] values() {  
        return $VALUES.clone();  
    }
    public static Sex valueOf(String name) { 
        return Enum.valueOf(Sex.class, name);  
    } 
   
}
匿名内部类
public class Demo8 {
   public static void main(String[] args) {
      Runnable runnable = new Runnable() {
         @Override
         public void run() {
            System.out.println("running...");
         }
      };
   }
}

转换后的代码

public class Demo8 {
   public static void main(String[] args) {
      //用额外创建的类来创建匿名内部类对象
      Runnable runnable = new Demo8$1();
   }
}

//创建了一个额外的类，实现了Runnable接口
final class Demo8$1 implements Runnable {
   public Demo8$1() {}

   @Override
   public void run() {
      System.out.println("running...");
   }
}

如果匿名内部类中引用了局部变量

public class Demo8 {
   public static void main(String[] args) {
      int x = 1;
      Runnable runnable = new Runnable() {
         @Override
         public void run() {
            System.out.println(x);
         }
      };
   }
}

转化后代码

public class Demo8 {
   public static void main(String[] args) {
      int x = 1;
      Runnable runnable = new Runnable() {
         @Override
         public void run() {
            System.out.println(x);
         }
      };
   }
}

final class Demo8$1 implements Runnable {
   //多创建了一个变量
   int val$x;
   //变为了有参构造器
   public Demo8$1(int x) {
      this.val$x = x;
   }

   @Override
   public void run() {
      System.out.println(val$x);
   }
}
小杰011
关注
专栏目录
【深入理解JVM 六】虚拟机字节码执行系统
MaoLin Tian's Blog
03-01 252
前边几篇Blog分别介绍了JVM的类加载机制、运行时数据区域，那么字节码文件已然被加载到了JVM的内存中来，接下来就是执行它了。虚拟机字节码执行引擎的位置如下图所示，除了本地方法栈，其他运行时数据区域它都有相关执行内容。 执行引擎是java虚拟机核心的组成部分之一，虚拟机的执行引擎是由软件自行实现的。执行引擎(Execution Engine)的任务就是将字节码指令解释/编译为对应平台上的本地机器指令。执行原则如下： 执行引擎在执行的过程中究竟需要执行什么样的字节码指令完全依赖于PC寄存器。每当执行完一
JVM学习笔记003：类加载与字节码技术
耿鬼不会笑的博客
04-18 366
黑马程序员：JVM学习笔记整理 四、类加载与字节码技术 1、类文件结构 首先获得.class字节码文件 方法： 在文本文档里写入java代码（文件名与类名一致），将文件类型改为.java java终端中，执行 javac -parameters -d . HellowWorld.java 以下是字节码文件 0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09 0000020 00 16 00 17 08 00 18 0a 00 19 0
JVM-编译期处理(语法糖)
百里屠苏的博客
04-16 332
文章目录编译期处理(语法糖)1 默认构造器2 自动拆装箱3 泛型集合取值4 可变参数5 foreach 循环6 switch 字符串7 switch 枚举8 枚举类9 匿名内部类 编译期处理(语法糖) 所谓的 语法糖 ，其实就是指 java 编译器把 *.java 源码编译为 *.class 字节码的过程中，自动生成 和转换的一些代码，主要是为了减轻程序员的负担，算是 java 编译器给我们的一个...
JVM第五卷---编译期处理
m0_53157173的博客
02-23 512
JVM第五卷编译期处理默认构造器自动拆装箱 编译期处理 所谓的 语法糖 ，其实就是指 java 编译器把 *.java 源码编译为 *.class 字节码的过程中，自动生成 和转换的一些代码，主要是为了减轻程序员的负担，算是 java 编译器给我们的一个额外福利（给糖吃 嘛） 注意，以下代码的分析，借助了 javap 工具，idea 的反编译功能，idea 插件 jclasslib 等工具。 另外，编译器转换的结果直接就是 class 字节码，只是为了便于阅读，给出了 几乎等价 的 java 源码方式，并
JVM类加载与字节码技术
两米以下皆凡人的博客
01-07 687
文章目录类加载与字节码技术1、类文件结构1.1、概述1.2、无关性的基石1.3、Class类文件结构1.3.1、魔数magic1.3.2、版本version1.3.3、常量池constant_pool1.3.3.1、标志位说明1.3.3.2、案例结合说明1.3.4、访问标志access_flags1.3.4.1、标志位说明1.3.4.2、案例结合说明1.3.5、包名类名this_class1.3.6、父类super_class1.3.7、接口interfaces_count1.3.8、字段fields1.3
深入理解JVM之早期（编译期）优化
Sweet Baby，甜宝
11-28 2015
读了深入理解JVM之早期优化这一章，JVM作者从编译期源码实现的层次上让我们了解了Java源代码编译为字节码的过程，分析了Java语言中泛型、主动装箱/拆箱、条件编译等多种语法糖的前因后果，并实战练习了如何使用插入式注解处理器来完成一个检查程序命令规范的编译器插件。在前端编译器中，“优化”手段主要用于提升程序的编码效率，之所以把Javac这类将java代码转变为字节码的编译器称做“前端编译器”，是
3_类加载与字节码技术2
08-03
本文将深入探讨类文件结构、字节码指令、编译期处理、类加载阶段、类加载器以及运行期优化。 1. **类文件结构** Java 类文件是二进制格式的，其结构遵循特定规范。以 HelloWorld.class 文件为例，文件头的四个字节...
深入学习JVM探针与字节码技术
大仙
10-07 1325
JVM探针是自jdk1.5以来，由虚拟机提供的一套监控类加载器和符合虚拟机规范的代理接口，结合字节码指令能够让开发者实现无侵入的监控功能。如：监控生产环境中的函数调用情况或动态增加日志输出等等。虽然在常规的业务中不会有太多用武之地，但是作为一项高级的技术手段也应该是资深开发人员的必备技能之一。同时，它也是企业级开发和生产环境部署不可或缺的技术方案，是对当下流行的APM的一种补充，因为使用探针技术能够实现比常规APM平台更细粒度的监控。 哪些方面适合使用探针技术： (1) 如果你发现生产环境上有些问题无法
JVM之字节码技术
Y_Ace的博客
05-03 576
字节码技术 1. 类文件结构 一个简单的HelloWorld.java public class HelloWorld { public static void main(String[] args) { System.out.println("hello world"); } } 执行javac -parameters -d . HellowWorld.java编译为 HelloWorld.class 后是这个样子的: 0000000 ca fe ba be 00 00
JVM篇-JVM加载字节码文件（.class）原理
luodaxia_ttt的博客
06-09 459
首先要知道JVM是啥其次知道JVM的组成再来看加载class文件的原理 首先要知道JVM是啥 JVM就是在计算机上再虚拟一个计算机，和VMWare不一样，VMWare你是可以看到的，而JVM你是看不到的，它存在内存中。计算机的基本构成是：运算器、控制器、存储器、输入和输出设备，那这个JVM 也是有这成套的元素，运算器是当然是交给硬件CPU 还处理了，只是为了适应“一次编译，随处运行”的情况，需要做一个翻译动作，于是就用了JVM 自己的命令集，这与汇编的命令集有点类似，每一种汇编命令集针对一个系列的CPU .
JVM学习笔记 04、类加载与字节码技术
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
05-05 694
文章目录前言一、类加载1.1、java文件、字节码文件1.2、类加载与字节码技术1.3、原理分析多态原理异常sychronized二、字节码指令2.3、编译器处理（语法糖）2.3.1-2.3.9（精简）2.3.10、方法重写时的桥接方法2.3.11、匿名内部类（底层原理、引用常量值）2.4、类加载阶段2.4.1、加载阶段2.4.2、链接验证准备解析2.4.3、初始化初始化练习（包装类静态属性、懒惰初始化单例）2.5、类加载器2.5.1、启动类加载器2.5.2、扩展类加载器2.5.3、双亲委派模式2.5.4、
java 动态字节码技术和类加载
叶新东老师的博客
04-19 1323
字节码有什么用？ 1、对类的基本信息进行操作 ，可以新增、删除、修改类、属性和方法； 2、应用场景：Lombok 插件、AOP、动态修改class文件、网页上的在线执行java代码也是字节码实现的； 2、Lombok 插件就是用字节码实现，只用Data注解就可以给属性自动加上get和set方法 4、 常见的字节码操作类库： BCEL： 深入汇编底层语言进行类库操作； ASM： 轻量级字节码操作框架，直接涉及到jVM底层的操作和指令；高性能、高质量 CGLB： 生成类...
类加载与字节码技术
qq_59676409的博客
04-28 583
1 类文件结构 通过 javac 类名.java 编译 java 文件后，会生成一个 .class 的文件！ 以下是字节码文件： 0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09 0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07 0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 0000060 56 01 00
JVM---类加载与字节码技术
weixin_44744094的博客
03-13 738
三、类加载与字节码技术 类文件结构 字节码指令 编译期处理 类加载阶段 类加载器 运行期优化 1. 类文件结构 一个简单的 HelloWorld.java // 二进制字节码（类基本信息，常量池，类方法定义，包含了虚拟机指令） public class HelloWorld { public static void main(String[] args) { System.out.println("hello world"); } } 执行 j
java compiler jpdk_Java学习之动态编译--字节码操作--javassist类库
weixin_42512933的博客
02-23 333
一、字节码操作1.Java动态性的两种常见实现方式：字节码操作反射2.运行时操作字节码可以实现如下功能：动态生成新的类动态改变某个类的结构(添加/删除/修改 新的属性/方法)3.优势：比反射开销小，性能高Javaasist性能高于反射，低于ASM二、常见的字节码操作类库1.BCELByte Code Engineering Library(BCEL)，这是Apache Software Found...
【JVM】类加载与字节码技术
小皮皮LL的博客
10-18 2126
文章目录JVM-类加载与字节码技术1.类文件结构1-1 魔数1-2 版本1-3 常量池2.字节码指令2-1 javap工具2-2 图解方法执行流程（1）原始 Java 代码（2）编译后的字节码文件（3）常量池载入运行时常量池（4）方法字节码载入方法区（5）main 线程开始运行，分配栈帧内存（6）执行引擎开始执行字节码2-3 练习-判断结果2-4 构造方法（1）cinit()V（2）init()V2-5 方法调用2-6 多态的原理2-7 异常处理（1）try-catch（2）多个 single-catch
JVM第四卷--类加载与字节码技术
m0_53157173的博客
02-23 631
JVM第四卷--类加载与字节码技术类加载与字节码技术类文件结构一个简单的 HelloWorld.javaClass类文件结构魔数版本常量池访问标识类索引,父类索引与接口所有集合字段表集合 类加载与字节码技术 类文件结构 字节码指令 编译期处理 类加载阶段 类加载器 运行期优化 类文件结构 一个简单的 HelloWorld.java // HelloWorld 示例 public class HelloWorld { public static void main(String[] ar
Java 类加载：字节码加载到Jvm中
笔记小屋
01-13 3027
前言 生成字节码后，这些数据如何加载到jsm中，并怎么存储成为了问题，本文主要研究一下这个内容。 加载到jvm 内存中 通过javac 转换成.class 字节码文件，这个时候计算机还是不能直接识别的，由jvm加载class文件，JVM的类加载是通过ClassLoader及其子类来完成的，再翻译成二进制指令，Java字节码的执行是由JVM解释器引擎来完成，类的层次关系和加载顺序可以由下图来描述： ...
类加载与字节码技术：类文件结构、字节码指令和编译期处理详解
总之，类加载与字节码技术是 Java 虚拟机的核心内容，它涉及到类文件结构、字节码指令、编译期处理、类加载阶段、类加载器和运行期优化等方面。深入理解这些内容可以帮助我们更好地理解 Java 虚拟机的工作原理，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值