jvm - 类的编译

编译

我们都知道,当我们编写完代码后,可以用javac命令或者开发工具,比如eclipse、idea等,把java文件编译成class文件,java虚拟机才可以执行。下图是WinHex打开class文件16进制的字节码。
image.png
每个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");
     }
}

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

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

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

泛型的擦除

看下面的例子:

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

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

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

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

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

用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;
   16      15     2 list2   Ljava/util/List;>;

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

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

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

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

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

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

反编译后如下,首先把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);
  }

另外看看下面的例子

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));
}

反编译后

  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())));
  }

条件编译

下面这个包括没有使用的变量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");
    }*/
}

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

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

你可能感兴趣的:(java,jvm)