jvm - 类的编译

编译

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

每一个class文件的前面四个字节成为魔数，它的惟一做用就是肯定这个文件是否能被虚拟机接受的文件，这个魔数值为0xCSAFEBABE（咖啡宝贝）。第五、6字节是次版本号，第七、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拼接起来。

泛型的擦除

看下面的例子：

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

反编译后，以下，竟然泛型还在，其实这个出乎个人意料以外，两年前给公司分享虚拟机的时候，个人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);
  }

因而我又换了另一个反编译器，反编译以下，此次确实没有泛型信息。

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<Ljava/lang/String;>;
   16      15     2 list2   Ljava/util/List<Ljava/util/Map<Ljava/lang/String;Ljava/lang/Integer;>;>;

由于泛型在编译期就会被擦除，因此如下的重载，是编译不过去的，由于擦除后，他们其实

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

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

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

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

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

反编译后以下，首先把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");
  }