# 《JVM核心技术》第02章：类的编译、编译优化、常量这地、泛型擦除、条件编译

大家好，我是冰河~~

今天，我们一起研究下JVM中类的编译问题，好了，不多说了，进入今天的正题。

# 编译

我们都知道，当我们编写完代码后，可以用javac命令或者开发工具，比如eclipse、idea等，把java文件编译成class文件，java虚拟机才可以执行。下图是WinHex打开class文件16进制的字节码。

每个class文件的前面四个字节成为魔数，它的唯一作用就是确定这个文件是否能被虚拟机接受的文件，这个魔数值为0xCSAFEBABE（咖啡宝贝）。第5、6字节是次版本号，第7、8字节是主版本号。从上图可以看到，我的主版本号是16进制的34，也就是10进制的52，52对应的JDK版本是1.8。

后面的16进制在这里不做过多的讲解，可以根据Java虚拟机规范的约定，以无符号数和表两种数据类型进行解析。

java文件编译成class文件的时候，先根据词法和语法分析获得了程序代码的抽象语法树表示，填充符号表，然后根据语义分析看程序是否符合逻辑，比如变量在使用前是否已经声明，变量是否正确赋值等，最后就是把前面步骤生成的信息（比如语法树），转换成字节码写到磁盘中，当然编译器还做了少量的代码添加（程序中没有构造函数，会添加无参构造函数的操作是在填充符号表完成的，不是这里完成)和转换工作。

# 编译优化

# 常量折叠

请看下面的例子：

public class HelloWord {
     public static void main(String[] args) {
           System.out.println("Hello," + " World");
     }
}

1
2
3
4
5

如果我把上面的代码，改成这样的，那么我在运行期的时候，会加重虚拟机的负担吗？答案是否定的。编译器除了检查外，还对常量进行了折叠，也就是说，上面的Hello World会在编译的时候自动拼接，如果是int型的，比如i = 1 + 2，等价于 i = 3，并不会增加程序在运行期哪怕一个CPU指令的运算量。

我们看看下面这个，如果是str += “c”呢，会不会折叠呢？

public void fun() {
    String str = "a" + "b";
    str += "c";
    System.out.println(str);
}

1
2
3
4
5

我们从下图的ASTView可以看出，标记1和标记2是不一样的类型，一个是变量赋值，第二个是表达式，在标记3可以看到，变量赋值的时候，自动把a和b拼接起来。

# 泛型的擦除

看下面的例子：

public static void main(String[] args) {
    List<String> list1 = new ArrayList<>();
    List<Map<String, Integer>> list2 = new ArrayList<>();
    System.out.println(list1);
    System.out.println(list2);
}

1
2
3
4
5
6

反编译后，如下，居然泛型还在，其实这个出乎我的意料之外，两年前给公司分享虚拟机的时候，我的ppt里还记录着泛型的擦除的案例，反编译后确实的没有泛型的。

  public static void main(String[] args) {
    List<String> list1 = new ArrayList<String>();
    List<Map<String, Integer>> list2 = new ArrayList<Map<String, Integer>>();
    System.out.println(list1);
    System.out.println(list2);
  }

1
2
3
4
5
6

于是我又换了另外一个反编译器，反编译如下，这次确实没有泛型信息。

  public static void main(String[] args)
  {
    List list1 = new ArrayList();
    List list2 = new ArrayList();
    System.out.println(list1);
    System.out.println(list2);
  }

1
2
3
4
5
6
7

用java自带的命令javap -verbose进行反编译，结果如下，可以看到泛型信息在只有调试用的LocalVariableTypeTable（LVTT）里，某些反编译器应该根据LVTT来展示泛型信息。

LocalVariableTable:
Start  Length  Slot  Name   Signature
    0      31     0  args   [Ljava/lang/String;
    8      23     1 list1   Ljava/util/List;
   16      15     2 list2   Ljava/util/List;
LocalVariableTypeTable:
Start  Length  Slot  Name   Signature
    8      23     1 list1   Ljava/util/List<Ljava/lang/String;>;
   16      15     2 list2   Ljava/util/List<Ljava/util/Map<Ljava/lang/String;Ljava/lang/Integer;>;>;

1
2
3
4
5
6
7
8
9

因为泛型在编译期就会被擦除，所以以下的重载，是编译不过去的，因为擦除后，他们其实

public static String fun(List<String> list) {
    return null;
}

public static Integer fun(List<Integer> list) {
    return null;
}

1
2
3
4
5
6
7

# 自动装箱、拆箱与循环遍历

这部分代码包括自动装箱、拆箱与循环遍历。

public void fun() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4);
    int sum = 0;
    for (int i : list) {
        sum += i;
    }
    System.out.println(sum);
}

1
2
3
4
5
6
7
8

反编译后如下，首先把int装箱变成Integer，然后计算的时候，再从Integer拆卸变成int。另外一个就是把for编译成Iterator迭代器。

public void fun()
{
    List list = Arrays.asList(new Integer[] { Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4) });
    int sum = 0;
    for (Iterator localIterator = list.iterator(); localIterator.hasNext(); ) { 
        int i = ((Integer)localIterator.next()).intValue();
        sum += i;
    }
    System.out.println(sum);
}

1
2
3
4
5
6
7
8
9
10

另外看看下面的例子

public static void main(String[] args) {
    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Integer d = 4;
    Integer e = 321;
    Integer f = 321;
    Long g = 3L;
    System.out.println(c == d);
    System.out.println(e == f);
    System.out.println(c == (a + b));
    System.out.println(c.equals(a + b));
    System.out.println(g == (a + b));
    System.out.println(g.equals(a + b));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

反编译后

  public static void main(String[] args)
  {
    Integer a = Integer.valueOf(1);
    Integer b = Integer.valueOf(2);
    Integer c = Integer.valueOf(3);
    Integer d = Integer.valueOf(4);
    Integer e = Integer.valueOf(321);
    Integer f = Integer.valueOf(321);
    Long g = Long.valueOf(3L);
    //为false，Integer对象，比较地址，两个地址不一样
    System.out.println(c == d);
    //为false，因为两个地址不一样
    System.out.println(e == f);
    //为true，都变成int，比较值
    System.out.println(c.intValue() == a.intValue() + b.intValue());
   //为true，equals方法比较int System.out.println(c.equals(Integer.valueOf(a.intValue() + b.intValue())));
   //为true，比较值
    System.out.println(g.longValue() == a.intValue() + b.intValue());
    //为false，类型不一样
    System.out.println(g.equals(Integer.valueOf(a.intValue() + b.intValue())));
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 条件编译

下面这个包括没有使用的变量a，if语句判断，while语句。

public static void main(String[] args) {
    int a;
    if(true){
        System.out.println("Hello");
    }else{
        System.out.println("World");
    }
   /* while(false){
        // Unreachable statement
        System.out.println("while");
    }*/
}

1
2
3
4
5
6
7
8
9
10
11
12

反编译后，没有使用的变量a并没有被编译，Dead code，也就是为false的部分也没有被编译，另外while那个，由于恒为false，编译器报Unreachable statement。

  public static void main(String[] args)
  {
    System.out.println("Hello");
  }

1
2
3
4

# 写在最后

在冰河的知识星球有大量从零开始带你手写的企业级生产项目，像DeepSeek大模型、手写高性能熔断组件、手写通用指标上报组件、手写高性能数据库路由组件、分布式IM即时通讯系统、Sekill分布式秒杀系统、手写RPC、简易商城系统等等，这些项目的需求、方案、架构、落地等均来自互联网真实业务场景，让你真正学到互联网大厂的业务与技术落地方案，并将其有效转化为自己的知识储备。

值得一提的是：冰河自研的Polaris高性能网关比某些开源网关项目性能更高，并且冰河也正在为企业级高性能RPC框架录制视频，全程带你分析原理和手撸代码。你还在等啥？不少小伙伴经过星球硬核技术和项目的历练，早已成功跳槽加薪，实现薪资翻倍，而你，还在原地踏步，抱怨大环境不好。抛弃焦虑和抱怨，我们一起塌下心来沉淀硬核技术和项目，让自己的薪资更上一层楼。

目前，领券加入星球就可以跟冰河一起学习《DeepSeek大模型》、《手写高性能通用熔断组件项目》、《手写高性能通用监控指标上报组件》、《手写高性能数据库路由组件项目》、《手写简易商城脚手架项目》、《手写高性能RPC项目》和《Spring6核心技术与源码解析》、《实战高并发设计模式》、《分布式Seckill秒杀系统》、《分布式IM即时通讯系统》和《手写高性能Polaris网关》，从零开始介绍原理、设计架构、手撸代码。

花很少的钱就能学这么多硬核技术、中间件项目和大厂秒杀系统与分布式IM即时通讯系统，比其他培训机构不知便宜多少倍，硬核多少倍，如果是我，我会买他个十年！

加入要趁早，后续还会随着项目和加入的人数涨价，而且只会涨，不会降，先加入的小伙伴就是赚到。

另外，还有一个限时福利，邀请一个小伙伴加入，冰河就会给一笔 分享有奖 ，有些小伙伴都邀请了50+人，早就回本了！