JVM 编译期处理（语法糖）

已于 2023-11-22 10:22:42 修改
阅读量330 收藏
点赞数
分类专栏： java 虚拟机 文章标签： java
于 2017-11-23 19:51:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhf852963/article/details/78618380
版权

一、简介

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

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

二、默认构造器

public class Candy {

    // 未提供任何的构造器
}

        编译成 class 后的代码如下

public class Candy {

    // 这个无参构造是编译器帮助我们加上的
    public Candy(){
        // 即调用父类 Object 的无参构造方法
        super();
    }
}

三、自动拆装箱

        自动拆装箱指的是 java 的基本类型和它的包装类型之间会有一个自动转换。这个特性是 jdk5 开始加入的，如下

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

// 上面的这段代码在 jdk5 之前是无法运行的，必须改成下面的这种写法
public class Candy2 {
    public static void main(String[] args) {
        Integer x = Integer.valueOf(1);
        int y=x.intValue();
    }
}

         显然之前版本的代码太麻烦了，需要在基本数据类型和包装类之间来回转换（尤其是集合类中操作的都是包装类型），因此这些转换的事情在 jdk5 以后都由编译器在编译阶段完成，即 Candy1 类会在编译阶段被转换成 Candy2。

四、泛型集合取值

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

public class Candy {
    public static void main(String[] args) {
      List<Integer> list = new ArrayList<Integer>();
        // 实际调用的是 List.add(Object e)
      list.add(10);
        // 实际调用的是 Object obj = List.get(int index)
      Integer x = list.get(0);
    }
}

        在取值的时候，编译器真正生成的字节码中，还要一个额外做一个类型转换的操作

// 需要将 Object 转换为 Integer
Integer x = (Integer) list.get(0);

        如果前面的 x 变量类型修改为 int 基本类型，那么最终生成的字节码是

// 需要将 Object 转为 Integer,并执行拆箱操作
int x = ((Integer)list.get(0)).intValue();

        幸运的是这些事情都不用自己来做。 

五、可变参数

        可变参数也是 jdk5 开始加入的新特性

public class Candy {
   public static void foo(String... args){
       // 直接赋值
       String [] argArr = args;
        System.out.println(argArr);
    }

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

}

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

public class Candy {
   public static void foo(String args []){
       // 直接赋值
       String [] argArr = args;
        System.out.println(argArr);
    }

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

        需要注意的是，如果调用了 foo() 则等价代码为 foo(new String []{})，创建了一个空的数据，而不会传递 null 进去。 

六、foreach 循环

        仍是 jdk5 开始加入的语法糖，数组的循环。

6.1 数组循环

public class Candy {
    public static void main(String[] args) {
        // 数组赋初值的简化写法也是语法糖
       int [] array = {1,2,3,4,5,6};
        for (int e:array) {
            System.out.println(e);
        }
    }
}

        会被编译器转换为

public class Candy {

    public Candy(){
    }
    public static void main(String[] args) {
        // 数组赋初值的简化写法也是语法糖
       int [] array = new int[]{1,2,3,4,5,6};
       for(int i=0;i<array.length;i++){
           int e= array[i];
           System.out.println(e);
       }
    }
}

 6.2 集合循环

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

        实际被编译器转换为对迭代器的调用

public class Candy {
    public Candy() {
    }
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer e = (Integer)iterator.next();
            System.out.println(e);
        }
    }
}

        需要注意的是，foreach 循环写法，能够配合数组，以及所有实现了 Iterator 接口的集合类一起使用，其中 Iterator 用来获取集合的迭代器（Iterator） 。

七、switch 字符串

        从 jdk7 开始，switch 可以作用于字符串和枚举类，这个功能其实也是语法糖，如下

public class Candy {
  public static void choose(String str){
      switch (str){
          case "hello":{
              System.out.println("h");
              break;
          }
          case "world":{
              System.out.println("w");
              break;
          }
      }
  }
}

        需要注意的是，switch 配合 String 和枚举使用时，变量不能为 null，具体原因如下

public class Candy {
    public Candy() {
    }
    public static void choose(String str) {
        byte x = -1;
        switch (str.hashCode()) {
            // hello 的 hashcode
            case 99162322:
                if (str.equals("hello")) {
                    x = 0;
                }
                break;
            // world 的 hashcode
            case 113318802:
                if (str.equals("world")) {
                    x = 1;
                }
        }
        switch (x) {
            case 0:
                System.out.println("h");
                break;
            case 1:
                System.out.println("w");
        }
    }
}

        可以看到，执行了两遍 switch ，第一遍是根据字符串的 hashCode 和 equals 将字符串转换为相应的 byte 类型，第二遍才是利用 byte 进行比较。 

        为什么第一遍时既比较 hashCode，又进行比较 equals 比较呢？hashCode 是为了提高效率，减少可能的比较，而 equals 是为了减少 hash 冲突。

八、switch 枚举

        switch 枚举的例子，原始代码如下

enum Sex{
    MAIL,FEMAIL
}
public class Candy {
    public static void foo(Sex sex){
        switch (sex){
            case MAIL:
                System.out.println("男");
                break;
            case FEMAIL:
                System.out.println("女");
                break;
        }
    }
}

         转换后代码如下

public class Candy {
    /**
     * 定义一个合成类（仅 JVM 使用，我们不可见）
     * 用来映射枚举的 oridinal 与数组元素的对应关系
     * 枚举的 oridinal 表示枚举对象的序号，从 0 开始
     * 即 MALE 的 oridinal()=0,FEMALE 的 oridinal()=1
     */
    static class $MAP{
        static int [] map = new int[2];
        static {
            map[Sex.MALE.ordinal()] = 1;
            map[Sex.FEMALE.ordinal()] = 2;
        }
    }
    public static void foo(Sex sex){
        // 数组的大小即为枚举元素的个数，里面存储 case 用来比对数字
        int x = $MAP.map[sex.ordinal()];
        switch (x){
            case 1:
                System.out.println("男");
                break;
        }
    }
}

九、枚举类

        jdk7 新增了枚举类，以前面的代码为例

enum Sex{
    MAIL,FEMAIL
}

        转换后的代码

public final class Sex extends Enum<Sex> {
    public static final Sex MALE;
    public static final Sex FEMALE;
    private static final Sex[] $VALUES;
    static {
        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);
    }
}

十、try-with-resources

        jdk7 开始新增了对需要关闭的资源处理的特殊写法，可以省略 finally 里面的代码，如下

try(资源变量 = 创建资源对象){
   
}catch(){
   
}

        其中资源对象需要实现 AutoCloseable 接口，例如 InputStream 、 OutputStream 、Connection 、 Statement 、 ResultSet 等接口都实现了 AutoCloseable ，使用 try-with-resources 可以不用写 finally 语句块，编译器会帮助生成关闭资源代码，如下

public class Candy {
    public static void main(String[] args) {
        try(InputStream is = new FileInputStream("d:\\1.txt")) {
            System.out.println(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

        会被转换为

public class Candy {
    public Candy9() {
    }

    public static void main(String[] args) {
        try {
            InputStream is = new FileInputStream("d:\\1.txt");
            Throwable t = null;
            try {
                System.out.println(is);
            } catch (Throwable e1) {
                // t 是我们代码出现的异常
                t = e1;
                throw e1;
            } finally {
                // 判断了资源不为空
                if (is != null) {
                    // 如果我们代码有异常
                    if (t != null) {
                        try {
                            is.close();
                        } catch (Throwable e2) {
                            // 如果 close 出现异常，作为被压制异常添加
                            t.addSuppressed(e2);
                        }
                    } else {
                        // 如果我们代码没有异常，close 出现的异常就是最后 catch 块中的 e
                        is.close();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

        为什么要设计一个 addSuppressed(Throwable e) （添加被压制异常）的方法呢？是为了防止异常信息的丢失（想想 try-with-resources 生成的 fianlly 中如果抛出了异常）

public class Candy {
    public static void main(String[] args) {
        try (MyResource resource = new MyResource()) {
            int i = 1/0;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class MyResource implements AutoCloseable {
    public void close() throws Exception {
        throw new Exception("close 异常");
    }
}

        输出如下：

java.lang.ArithmeticException: / by zero
	at test.Test6.main(Test6.java:7)
	Suppressed: java.lang.Exception: close 异常
		at test.MyResource.close(Test6.java:18)
		at test.Test6.main(Test6.java:6)

        如以上代码所示，两个异常信息都不会丢失。

十一、方法重写时的桥接方法

        我们都知道，方法重写时对返回值分两种情况。第一种父子类的返回值完全一致；第二种子类返回值可以是父类返回值的子类。

class A {
    public Number m() {
        return 1;
    }
}
class B extends A {
    @Override
    // 子类 m 方法的返回值是 Integer 是父类 m 方法返回值 Number 的子类
    public Integer m() {
        return 2;
    }
}

        对于子类，java 编译器会做如下处理

class B extends A {
    public Integer m() {
        return 2;
    }
    // 此方法才是真正重写了父类 public Number m() 方法
    public synthetic bridge Number m() {
        // 调用 public Integer m()
        return m();
    }
}

        其中桥接方法比较特殊，仅对 java 虚拟机可见，并且与原来的 public Integer m() 没有命名冲突，可以用下面反射代码来验证： 

for (Method m : B.class.getDeclaredMethods()) {
    System.out.println(m);
}

        会输出

public java.lang.Integer test.candy.B.m()
public java.lang.Number test.candy.B.m()

十二、匿名内部类

public class Candy11 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("ok");
            }
        };
    }
}

        转换后的代码如下

// 额外生成的类
final class Candy11$1 implements Runnable {
    Candy11$1() {
    }
    public void run() {
        System.out.println("ok");
    }
}

public class Candy11 {
    public static void main(String[] args) {
        Runnable runnable = new Candy11$1();
    }
}

        引用局部变量的匿名内部类，代码如下：

public class Candy11 {
    public static void test(final int x) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("ok:" + x);
            }
        };
    }
}

        转换后的代码如下：

// 额外生成的类
final class Candy11$1 implements Runnable {
    int val$x;
    Candy11$1(int x) {
        this.val$x = x;
    }
    public void run() {
        System.out.println("ok:" + this.val$x);
    }
}

public class Candy11 {
    public static void test(final int x) {
        Runnable runnable = new Candy11$1(x);
    }
}

        需要注意的是，这里解释了为什么匿名内部类引用局部变量时，局部变量必须是 final 的：因为在创建 Candy11$1 对象时，将 x 的值赋值给了 Candy11$1 对象的 val$x 属性，所以 x 不应该再发生变化了，如果变化，那么 val$x 属性没有机会再跟着一起变化。

快乐的小三菊
关注
专栏目录
字符串intern()方法详解
zs357的博客
12-13 1万+
1. intern()方法简介 如果字符串s在字符串常量池中存在对应字面量，则intern()方法返回该字面量的地址；如果不存在，则创建一个对应的字面量，并返回该字面量的地址 2. String对象与字面量的intern()区别 public static void main(String[] args) { String s1 = new String("字符串"); String s2 = "字符串"; System.out.println
Java编译期和运行期 & JVM
bingguang1993的博客
08-28 471
Java代码编译是由Java源码编译器来完成，流程图如下所示： Java字节码的执行是由JVM执行引擎来完成，流程图如下所示： 如下图，Java程序从源文件创建到程序运行要经过两大步骤：1、源文件由编译器编译成字节码（ByteCode） 2、字节码由java虚拟机解释运行。因为java程序既要编译同时也要经过JVM的解释运行，所以说Java被称为半解释语言（...
jvm系列一：Java代码编译、执行及类加载
好习惯要坚持下去
02-06 5015
Java代码编译是由Java源码编译器来完成，流程图如下所示： Java字节码的执行是由JVM执行引擎来完成，流程图如下所示：   Java代码编译和执行的整个过程包含了以下三个重要的机制： Java源码编译机制 类加载机制 类执行机制 Java源码编译机制 Java 源码编译由以下三个过程组成： 分析和输入到符号表 注解处理 语义分析和生成class文件 流程图如下所...
JVM、Java编译器和Java解释器
热门推荐
Bill好想
06-06 2万+
JVM：Java主要靠Java虚拟机（JVM）在目标码级实现平台无关性。JVM是一种抽象机器，它附着在具体操作系统之上，本身具有一套虚机器指令，并有自己的栈、寄存器组等。但JVM通常是在软件上而不是在硬件上实现。JVM是Java平台无关的基础。JVM不仅仅只去执行字节码，它还有好多任务要去做。 Java编译器：javac.exe可以看成是Java编译器。 Java解释器：是
JVM:早期(编译期)优化的深入理解
08-26
JVM 早期（编译期）优化的深入理解 JVM 的编译器可以分为三个编译器：...JVM 的编译器在编译期可以进行多种优化，包括解析与符号填充、注解处理和语义分析与字节码生成等过程，每个过程都可以对编译器的行为产生影响。
深入理解JVM - 编译期/运行期优化
json_it的博客
01-31 1417
----------------------------编译期优化-------------------------------------- 1、概述（编译期） Java语言的“编译期”其实是一段“不确定”的操作过程，因为它可能是指一个前端编译器（Javac编译器）把Java文件转变为class文件的过程；也可能是指虚拟机的后端运行期编译器（JIT编译器）把字节码转变为机器码的过程；还可能是
Java进阶之泛型与语法糖
lishinho的博客
07-19 823
Java泛型是一个重要的Java概念，虽然Java的继承和接口丰富了多态的灵活性，但我们仍然希望编写更通用的代码，能够适用“非特定的类型”，而不是一个具体的接口或类。同时泛型是如何产生并使用的，我们的代码里泛型究竟充当了什么样的角色？ 一，Java的编译期与运行期 从你写下Java代码（打印helllo world）到运行显示出你输入的效果，你的Java程序究竟经历了什么？ 程序从高级程序语言编译到机器语言；通过编译器的语法糖优化java程序用于提高代码效率 Java程序的编译与优化分为两个阶段，一
JVM学习总结（八）：Java 语法糖及实现——泛型和Stream的实现原理
weixin_42208959的博客
08-07 429
前言 正文 一、Java 中的泛型——Java 语言的一颗语法糖 1、泛型是什么？ 泛型，即“参数化类型”，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。 引入一个类型变量 T（其他大写字母都可以，不过常用的就是 T，E，K，V 等等），并且用<>括起来，并放在类名的后面。泛型类是允许有多个类型变量的。 按照约定，类型参数名称命名为单个大写字母，以便可以在使用普通类或接口名称时能够容易地区分类型参数。以下是常用的类型参数名称列表： E - 元素，主要由 Java 集合(Collec
JVM编译器的编译过程
tingfeng96的专栏
08-20 6821
一、编译器概述 本片文章叙述的是HotSpot虚拟机的编译过程，HotSpot包含一个解释器javac和两个即时编译器，它们之间配合工作。 解释器与编译器： 1、解释器与编译器两者各有优势，当程序需要快速启动和执行的时候，解释器可以后先发挥作用，省去编译时间，立即执行。在程序运行后，随着时间的推移，编译器逐渐发挥作用，把越来越多的代码编译成本地代码之后，可以获得更高的执行效率
Java编译期的优化
Hi_alan的博客
01-07 365
语法糖 所谓的 语法糖 ，其实就是指 java 编译器把 *.java 源码编译为 *.class 字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员的负担，算是 java 编译器给我们的一个额外福利（给糖吃嘛） 1 默认构造器 public class Candy1 { } 编译成class后的代码： public class Candy1 { // 这个无参构造是编译器帮助我们加...
[记录] 关于字符串intern()在jdk1.6和jdk1.7及以上的差异
weixin_54345825的博客
10-19 216
关于字符串intern()在jdk1.6和jdk1.7及以上的差异
JVM-intern方法在1.6和1.8版本实现区别
最新发布
程序员朱永胜
11-14 716
它的作用是将字符串对象添加到字符串常量池中，并且如果字符串常量池已经存在相同内容的字符串，则返回对该字符串的引用。中，字符串是不可变的，当我们频繁地创建字符串对象时，会产生很多相同内容的字符串对象，这样会占用大量的内存空间。Java 1.6 版本中，如果字符串常量池中已经存在相同内容的字符串，就不会再创建新的字符串对象，而是直接返回常量池中的字符串引用。方 ✽✽ 在字符串常量池中创建额外的字符串对象，如果字符串常量池中已经存在相同内容的字符串，会浪费一定的内存空间。，其内容也为 "Hello"。
String中intern的方法
10-21 919
首先查看官方API那个的解释： ——————————————————————————————————————— intern public String intern() 返回字符串对象的规范化表示形式。 一个初始时为空的字符串池，它由类 String 私有地维护。 当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals...
intern() 方法
a290450134的博客
05-24 4806
intern() 方法返回字符串对象的规范化表示形式。 它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。 具体不做介绍，请看引用：http://www.runoob.com/java/java-string-intern.html 来一段有意思东西： //1： ...
intern()详解
aaaayl的博客
08-12 2751
jdk1.7之后的intern()方法的作用： 1、若是字符串常量池中不存在这个字符串,那么，就创建一个引用，把该字符串实例对象的引用复制过来，并返回该地址。 2、若是字符串常量池中已存在该字符串，那么直接返回该字符串的地址。 下面举几个例子： 当使用intern()方法时，该字符串还未存在于常量池中。 public void internIsNotExistedTest() { String a = new String("a") + new String("b");
“java“.intern==“java“为false（intern方法解析）
山高水长
11-18 360
对Java中String.intern()方法的理解 String.intern()在API中的解释 public class A { public static void main(String[] args) { String s1 = new StringBuilder("go") .append("od").toString(); System.out.println(s1.intern() == s1); String s2 = new StringBuilder
java编译期和运行期
07-25
Java的编译期和运行期是指Java程序的两个主要阶段。 编译期是指将Java源代码文件（.java文件）转换为字节码文件（.class文件）的过程。在这个阶段，Java编译器将源代码翻译成字节码，检查代码语法和类型错误，并生成可执行的字节码文件。编译器会进行语法检查、语义检查、类型检查等操作，确保代码的正确性和可执行性。如果在编译期间发现错误，编译器会生成错误信息，程序无法继续执行。 运行期是指在编译期生成的字节码文件被Java虚拟机（JVM）加载和执行的阶段。在这个阶段，JVM将字节码文件加载到内存中，并逐行解释执行。在运行期间，JVM会对字节码进行优化和动态编译，以提高程序的性能。如果在运行期间发生错误，JVM会抛出异常并终止程序的执行。 总结起来，编译期是将Java源代码转换为字节码的过程，而运行期是将字节码加载到JVM并执行的过程。这两个阶段是Java程序执行的必要步骤。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐的小三菊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值