了解一下Java字节码

package bytecode;
/**
 * 这是一个空的Java类
 *
 * @author liaojunyong
 */
public class EmptyClass {
}

java.lang.UsupportedClassVersionError: Unsupported major.minor version 52.0

% mvn -version

Apache Maven 3.6.2 (40f52333136460af0dc0d7232c0dc0bcf0d9e117; 2019-08-27T23:06:16+08:00)
Maven home: /usr/local/Cellar/maven/3.6.2/libexec
Java version: 13, vendor: Oracle Corporation, runtime: /jdk-13.jdk/Contents/Home
Default locale: zh_CN_#Hans, platform encoding: UTF-8
OS name: "mac os x", version: "10.15.1", arch: "x86_64", family: "mac"

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.0</version>
    <configuration>
        <source>13</source>
        <target>13</target>
        <encoding>UTF-8</encoding>
    </configuration>
</plugin>

% mvn clean compile

CONSTANT_Utf8_info {
  u1 tag;
  u2 length;
  u1 bytes[length];
}

CONSTANT_Integer_info {
  u1 tag;
  u4 bytes;
}

CONSTANT_Float_info {
  u1 tag;
  u4 bytes;
}

CONSTANT_Long_info {
  u1 tag;
  u4 high_bytes;
  u4 low_bytes;
}

CONSTANT_Double_info {
  u1 tag;
  u4 high_bytes;
  u4 low_bytes;
}

CONSTANT_String_info {
  u1 tag;
  u2 string_index;
}

CONSTANT_Class_info {
  u1 tag;
  u2 name_index;
}

CONSTANT_NameAndType_info {
  u1 tag;
  u2 name_index;
  u2 decription_index;
}

CONSTANT_Methodref_info {
  u1 tag;
  u2 class_index;
  u2 name_and_type_index;
}

CONSTANT_Fieldref_info {
  u1 tag;
  u2 class_index;
  u2 name_and_type_index;
}

CONSTANT_Fieldref_info {
  u1 tag;
  u2 class_index;
  u2 name_and_type_index;
}

CONSTANT_MethodType_info {
  u1 tag;
  u2 description_index;
}

CONSTANT_InvokeDynamic_info {
  u1 tag;
  u2 bootstrap_method_attr_index;  // 定位到一个引导方法
  u2 name_and_type_index;
}

CONSTANT_MethodHandle_info {
  u1 tag;
  u2 reference_kind;
  u2 reference_index;
}

package bytecode;
/**
 * 这是一个空的Java类
 *
 * @author liaojunyong
 */
public class EmptyClass {
    /**
     * 缺省构造函数
     */
    public EmptyClass() {
        super();
    }
}

package bytecode;

/**
 * 这是一个简单的Java类
 *
 * @author liaojunyong
 */
public class PageClass {
    /** 定义常量 */
    private static final int size = 10;
    /** 当前第几页 */
    private int page;
    
    /** 构造函数 */
    public PageClass(int page) {
        this.page = page;
    }

    /** 计算偏移量 */
    public int calculateOffset() {
        return page * size;
    }

    /** 程序入口 */
    public static void main(String[] args) {
        PageClass page = new PageClass(3);
        System.out.println(page.calculateOffset());
    }
}

u2 : 当前类 （指向常量池中的Class）
u2 : 父类 （指向常量池中的Class）
u2 : 实现的接口数 (实现的接口个数，没有实现接口为0)
u2 : 接口数组 （指向常量池中的Class，必须是接口）

public class PageClass implements Serializable, Comparable<PageClass>{...}

attribute_info {
  u2 : attribute_name_index;  (当前attribute的名称)
  u4 : attribute_length;  (当前attribute的长度)
  u1 : info[attribute_length]; (当前attribute的值)
}

Code_attribute{
  u2 : attribute_name_index; (属性名，指向常量池的常量，总是 Code)
  u4 : attribute_length;  （Code属性的剩余长度，不包括前6个字节 u2+u4）
  u2 : max_stack;  (操作数栈的最大深度)
  u2 : max_locals;  (局部变量的最大个数)
  u4 : code_length;  (字节码长度)
  u1 : code[code_length];  (字节码内容)
  u2 : exception_table_length;  (异常表的个数)
  exception_info : exception_table[exception_table_length];  (异常表)
  u2 : attributes_count;
  attribute_info : attributes[attributes_count];
} 

exception_info{
  u2 : start_pc;  (字节码的开始偏移量)
  u2 : end_pc;  (字节码的结束偏移量)
  u2 : handler_pc;  (catch异常的处理代码偏移量)
  u2 : catch_type;  (需要catch的异常类型，指向常量池的索引)
}

{
  u2 : attribute_name_index;
  u4 : attribute_length;
  u2 : line_number_table_length;
  line_number_info : line_number_tables[line_number_table_length];
}

line_number_info {
  u2 : start_pc;
  u2 : line_number;
}

{
  u2 : attribute_name_index;
  u4 : attribute_length;
  u2 : local_variable_table_length;
  local_variable_info : local_variable_tables[local_variable_table_length];
}

local_variable_info{
  u2 : start_pc;  (变量声明周期的开始量)
  u2 : length;  (变量声明周期的结束量)
  u2 : name_index; (常量池引用)
  u2 : decriptor_index;  (描述引用)
  u2 : index;  (局部变量在栈帧局部变量表中Slot的位置，如果是64位变量long/double，占用两个Slot)
}

{
  u2 : attribute_name_index;
  u4 : attribute_length;
  u2 : sourcefile_index;  (常量池引用，文件名)
}

{
  u2 : attribute_name;
  u4 : attribute_length;
  u2 : constant_value_index;  (常量池引用)
}

u2 : field_count
field_info : fields[field_count]

field_info {
  u2 : access_flags;  (类似于class 的 访问标记)
  u2 : name_index; (指向常量池中的 Utf8)
  u2 : descriptor_index; (指向常量池中的 Utf8)
  u2 : attributes_count; (字段可能还有一些额外的属性，这是属性个数)
  attribute_info : attributes[attributes_count]
}

001A 001F 000C 0001 0020 0000 0002 0021

field_info {
  u2 : 001A;  (final + private + static)
  u2 : 001F;  (指向常量池中的 31-Utf8 : size)
  u2 : 000C;  (指向常量池中的 12-Utf8 : l)
  u2 : 0001;  (一个额外属性)
  attribute_info : {
    u2 : 0020; (指向常量池中的 32-Utf8 : Constant Value)
    u4 : 0000 0002; (2个字节)
    u2 : 0021; (指向常量池中的 33-Integer : 10)
  }
}

0002 000B 000C 0000

field_info {
  u2 : 0002;  (private)
  u2 : 000B;  (指向常量池中的 11-Utf8 : page)
  u2 : 000C;  (指向常量池中的 12-Utf8 : l)
  u2 : 0000;  (没有额外属性)
}

u2 : methods_count;
method_info : methods[methods_count];

method_info {
  u2 : access_flags; (访问标记)
  u2 : name_index; (方法名，指向常量池的索引)
  u2 : descriptor_index;  (描述符，指向常量池的索引)
  u2 : attributes_count;
  attribute_info : attributes[attributes_count];
}

Object m(int i, double d, Thread t){...}

(IDLjava/lang/Thread;)Ljava/lang/Object;

/**
 * 用于测试参数类型
 *
 * @param a
 * @param b
 * @param c
 * @param d
 * @param e
 * @param f
 * @param g
 * @param h
 * @param i
 * @param j
 * @return
 */
public static PageClass of(long a, float b, double c, int d, short e, 
        char f, byte g, boolean h, String i, EmptyClass j) {
    return new PageClass(0);
}

(JFDISCBZLjava/lang/String;Lbytecode/EmptyClass;)Lbytecode/PageClass;

0001 0005 000F 0001 
  0022 00000046 0002 0002 0000000A 
    2AB70001 2A1BB500 07B1  // 字节码
  0000 0002
    0023 0000000E 0003      // LineNumberTable
      0000  0018
      0004  0019
      0009  001A
    0024 00000016 0002      // LocalVariableTable
      0000 000A 0025 0026 0000 
      0000 000A 000B 000C 0001

{
  u2 : 0001;  (public)
  u2 : 0005;  (5-Utf8 : <init>)
  u2 : 000F;  (15-Utf8 : (l)V)
  u2 : 0001;  (一个属性)
  attribute_info {
    u2 : 0022;  (34-Utf8 : Code)
    u4 : 0000 0046;  (数据长度为70)
    u2 : 0002;  (操作数栈的最大深度)
    u2 : 0002;  (局部变量的最大个数)
    u4 : 0000000A;  (字节码长度=10)
    Code {    //2AB70001 2A1BB500 07B1;  (字节码内容)
      0 aload_0
      1 invokespecial #1 <java/lang/Object.<init>>
      4 aload_0
      5 iload_1
      6 putfield #7 <bytecode/PageClass.page>
      9 return
    }
    u2 : 0000;  (异常表的个数:0)
    u2 : 0002;  (两个属性)
    attributes [
      {
        u2 : 0023;  (35-Utf8 : LineNumberTable，源代码行号)
        u4 : 0000000E;  (长度 : 14)
        u2 : 0003;  (三个 line_number_info)
        line_number_tables[
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 0018;  (line_number : 24)  // public PageClass(int page) {
          },
          {
            u2 : 0004;  (start_pc : 4)
            u2 : 0019;  (line_number : 25)  // this.page = page;
          },
          {
            u2 : 0009;  (start_pc : 9)
            u2 : 001A;  (line_number : 26)  // }
          }
        ]
      },
      {
        u2 : 0024;  (36-Utf8 : LocalVariableTable ， 内部变量)
        u4 : 00000016;  (长度 : 22)
        u1 : 0002;  (内部变量个数 : 2)
        local_variable_tables[
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 000A;  (length : 10)
            u2 : 0025;  (name_index，37-Utf8 : this)
            u2 : 0026;  (descriptor_index，38-Utf8 : Lbytecode/PageClass;)
            u2 : 0000;  (index : 0 , 第1个内部变量)
          },
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 000A;  (length : 10)
            u2 : 000B;  (name_index，11-Utf8 : page)
            u2 : 000C;  (descriptor_index，12-Utf8 : l)
            u2 : 0001;  (index : 1 , 第2个内部变量)
          }
        ]
      }
    ]
  }
}

0001 0018 0019 0001 
  0022 00000032 0002 0001 00000008
    2AB40007 100A68AC   // 字节码
  0000 0002
    0023 00000006 0001  // LineNumberTable
      0000 0022
    0024 0000000C 0001  // LocalVariableTable
      0000 0008 0025 0026 0000

{
  u2 : 0001;  (public)
  u2 : 0018;  (24-Utf8 : calculateOffset)
  u2 : 0019;  (25-Utf8 : ()l)
  u2 : 0001;  (一个属性)
  Code_attribute{
    u2 : 0022;  (34-Utf8 : Code)
    u4 : 0000 0032;  (数据长度为50)
    u2 : 0002;  (操作数栈的最大深度)
    u2 : 0001;  (局部变量的最大个数)
    u4 : 00000008;  (字节码长度=8)
    Code {    //2AB40007 100A68AC;  (字节码内容)
      0 aload_0
      1 getfield #7 <bytecode/PageClass.page>
      4 bipush 10
      6 imul
      7 ireturn  
    }
    u2 : 0000;  (异常表的个数:0)
    u2 : 0002;  (两个属性)
    attributes[
      {
        u2 : 0023;  (35-Utf8 : LineNumberTable，源代码行号)
        u4 : 00000006;  (长度 : 6)
        u2 : 0001;  (1个 line_number_info)
        line_number_tables[
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 0022;  (line_number : 34)  // return page * size;
          }
        ]
      },
      {
        u2 : 0024;  (36-Utf8 : LocalVariableTable ， 内部变量)
        u4 : 0000000C;  (长度 : 12)
        u1 : 0001;  (内部变量个数 : 1)
        local_variable_tables[
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 0008;  (length : 8)
            u2 : 0025;  (name_index，37-Utf8 : this)
            u2 : 0026;  (descriptor_index，38-Utf8 : Lbytecode/PageClass;)
            u2 : 0000;  (index : 0 , 第1个内部变量)
          }
        ]
      }
    ]
  } 
}

0009 0027 0028 0001 
  0022 00000050 0003 0002 00000014 
    BB000859 06B7000D 4CB20010 2BB60016 B6001AB1    // 字节码
  0000 0002
    0023 0000000E 0003    //LineNumberTable
      0000 002B
      0009 002C
      0013 002D 
    0024 00000016 0002    // LocalVariableTable
      0000 0014 0029 002A 0000 
      0009 000B 000B 0026 0001

{
  u2 : 0009;  (public + static)
  u2 : 0027;  (39-Utf8 : main)
  u2 : 0028;  [ 40-Utf8 : ([Ljava/lang/String;)V  ]
  u2 : 0001;  (一个属性)
  Code_attribute{
    u2 : 0022;  (34-Utf8 : Code)
    u4 : 0000 0050;  (数据长度为80)
    u2 : 0003;  (操作数栈的最大深度)
    u2 : 0002;  (局部变量的最大个数)
    u4 : 00000014;  (字节码长度=20)
    u1[20] : BB000859 06B7000D 4CB20010 2BB60016 B6001AB1;  (字节码内容)
    {
       0 new #8 <bytecode/PageClass>
       3 dup
       4 iconst_3
       5 invokespecial #13 <bytecode/PageClass.<init>>
       8 astore_1
       9 getstatic #16 <java/lang/System.out>
      12 aload_1
      13 invokevirtual #22 <bytecode/PageClass.calculateOffset>
      16 invokevirtual #26 <java/io/PrintStream.println>
      19 return
    }
    u2 : 0000;  (异常表的个数:0)
    u2 : 0002;  (两个属性)
    attributes[
      {
        u2 : 0023;  (35-Utf8 : LineNumberTable，源代码行号)
        u4 : 0000000E;  (长度 : 14)
        u2 : 0003;  (3个 line_number_info)
        line_number_tables[
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 002B;  (line_number : 33)  // PageClass page = new PageClass(3);
          },
          {
            u2 : 0009;  (start_pc : 0)
            u2 : 002C;  (line_number : 44)  // System.out.println(page.calculateOffset());
          },
          {
            u2 : 0013;  (start_pc : 0)
            u2 : 002D;  (line_number : 45)  // }
          }
        ]
      }
      {
        u2 : 0024;  (36-Utf8 : LocalVariableTable ， 内部变量)
        u4 : 00000016;  (长度 : 22)
        u1 : 0002;  (内部变量个数 : 2)
        local_variable_tables[
          {
            u2 : 0000;  (start_pc : 0)
            u2 : 0014;  (length : 20)
            u2 : 0029;  (name_index，41-Utf8 : args)
            u2 : 002A;  (descriptor_index，42-Utf8 : Ljava/lang/String;)
            u2 : 0000;  (index : 0 , 第1个内部变量)
          },
          {
            u2 : 0009;  (start_pc : 0)
            u2 : 000B;  (length : 20)
            u2 : 000B;  (name_index，11-Utf8 : page)
            u2 : 0026;  (descriptor_index，38-Utf8 : Lbytecode/PageClass;)
            u2 : 0001;  (index : 1 , 第2个内部变量)
          }
        ]
      }
    ]
  } 
}

{
  u2 : 0001; (有一个扩展属性)
  attributes[
    {
      u2 : 002B;  (43-Utf8 : SourceFile)
      u4 : 0000002C;  
      u2 : 002C;  (44-Utf8 : PageClass.java)
    }
  ]
}

用法: javap <options> <classes>
其中, 可能的选项包括:
  -? -h --help -help               输出此帮助消息
  -version                         版本信息，javap 的版本，不是 class 文件的编译版本
  -v  -verbose                     输出附加信息
  -l                               输出行号和本地变量表
  -public                          仅显示公共类和成员
  -protected                       显示受保护的/公共类和成员
  -package                         显示程序包/受保护的/公共类
                                   和成员 (默认)
  -p  -private                     显示所有类和成员
  -c                               对代码进行反汇编
  -s                               输出内部类型签名
  -sysinfo                         显示正在处理的类的
                                   系统信息（路径、大小、日期、SHA-256 散列）
  -constants                       显示最终常量
  --module <模块>, -m <模块>       指定包含要反汇编的类的模块
  --module-path <路径>             指定查找应用程序模块的位置
  --system <jdk>                   指定查找系统模块的位置
  --class-path <路径>              指定查找用户类文件的位置
  -classpath <路径>                指定查找用户类文件的位置
  -cp <路径>                       指定查找用户类文件的位置
  -bootclasspath <路径>            覆盖引导类文件的位置
  --multi-release <version>        指定要在多发行版 JAR 文件中使用的版本

% javap -v target/classes/bytecode/PageClass.class 
Classfile /Users/liaojunyong/Workspaces/ResearchDistributed/research-java/target/classes/bytecode/PageClass.class
  Last modified 2019年12月18日; size 743 bytes
  SHA-256 checksum c8ea8361a2784888c50d6c7d3ad2fa825ffa34fa5945d437f1bdb194950dd58e
  Compiled from "PageClass.java"
  
public class bytecode.PageClass
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #8                          // bytecode/PageClass
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 2, methods: 3, attributes: 1
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // bytecode/PageClass.page:I
   #8 = Class              #10            // bytecode/PageClass
   #9 = NameAndType        #11:#12        // page:I
  #10 = Utf8               bytecode/PageClass
  #11 = Utf8               page
  #12 = Utf8               I
  #13 = Methodref          #8.#14         // bytecode/PageClass."<init>":(I)V
  #14 = NameAndType        #5:#15         // "<init>":(I)V
  #15 = Utf8               (I)V
  #16 = Fieldref           #17.#18        // java/lang/System.out:Ljava/io/PrintStream;
  #17 = Class              #19            // java/lang/System
  #18 = NameAndType        #20:#21        // out:Ljava/io/PrintStream;
  #19 = Utf8               java/lang/System
  #20 = Utf8               out
  #21 = Utf8               Ljava/io/PrintStream;
  #22 = Methodref          #8.#23         // bytecode/PageClass.calculateOffset:()I
  #23 = NameAndType        #24:#25        // calculateOffset:()I
  #24 = Utf8               calculateOffset
  #25 = Utf8               ()I
  #26 = Methodref          #27.#28        // java/io/PrintStream.println:(I)V
  #27 = Class              #29            // java/io/PrintStream
  #28 = NameAndType        #30:#15        // println:(I)V
  #29 = Utf8               java/io/PrintStream
  #30 = Utf8               println
  #31 = Utf8               size
  #32 = Utf8               ConstantValue
  #33 = Integer            10
  #34 = Utf8               Code
  #35 = Utf8               LineNumberTable
  #36 = Utf8               LocalVariableTable
  #37 = Utf8               this
  #38 = Utf8               Lbytecode/PageClass;
  #39 = Utf8               main
  #40 = Utf8               ([Ljava/lang/String;)V
  #41 = Utf8               args
  #42 = Utf8               [Ljava/lang/String;
  #43 = Utf8               SourceFile
  #44 = Utf8               PageClass.java
{
  public bytecode.PageClass(int);
    descriptor: (I)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iload_1
         6: putfield      #7                  // Field page:I
         9: return
      LineNumberTable:
        line 24: 0
        line 25: 4
        line 26: 9
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  this   Lbytecode/PageClass;
            0      10     1  page   I

  public int calculateOffset();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: getfield      #7                  // Field page:I
         4: bipush        10
         6: imul
         7: ireturn
      LineNumberTable:
        line 34: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       8     0  this   Lbytecode/PageClass;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=2, args_size=1
         0: new           #8                  // class bytecode/PageClass
         3: dup
         4: iconst_3
         5: invokespecial #13                 // Method "<init>":(I)V
         8: astore_1
         9: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
        12: aload_1
        13: invokevirtual #22                 // Method calculateOffset:()I
        16: invokevirtual #26                 // Method java/io/PrintStream.println:(I)V
        19: return
      LineNumberTable:
        line 43: 0
        line 44: 9
        line 45: 19
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      20     0  args   [Ljava/lang/String;
            9      11     1  page   Lbytecode/PageClass;
}
SourceFile: "PageClass.java"

% javac
用法: javac <options> <source files>
其中, 可能的选项包括:
  @<filename>                  从文件读取选项和文件名
  -Akey[=value]                传递给注释处理程序的选项
  --add-modules <模块>(,<模块>)*
        除了初始模块之外要解析的根模块; 如果 <module>
                为 ALL-MODULE-PATH, 则为模块路径中的所有模块。
  --boot-class-path <path>, -bootclasspath <path>
        覆盖引导类文件的位置
  --class-path <path>, -classpath <path>, -cp <path>
        指定查找用户类文件和注释处理程序的位置
  -d <directory>               指定放置生成的类文件的位置
  -deprecation                 输出使用已过时的 API 的源位置
  --enable-preview             启用预览语言功能。要与 -source 或 --release 一起使用。
  -encoding <encoding>         指定源文件使用的字符编码
  -endorseddirs <dirs>         覆盖签名的标准路径的位置
  -extdirs <dirs>              覆盖所安装扩展的位置
  -g                           生成所有调试信息
  -g:{lines,vars,source}       只生成某些调试信息
  -g:none                      不生成任何调试信息
  -h <directory>               指定放置生成的本机标头文件的位置
  --help, -help, -?            输出此帮助消息
  --help-extra, -X             输出额外选项的帮助
  -implicit:{none,class}       指定是否为隐式引用文件生成类文件
  -J<flag>                     直接将 <标记> 传递给运行时系统
  --limit-modules <模块>(,<模块>)*
        限制可观察模块的领域
  --module <模块>(,<模块>)*, -m <模块>(,<模块>)*
        只编译指定的模块，请检查时间戳
  --module-path <path>, -p <path>
        指定查找应用程序模块的位置
  --module-source-path <module-source-path>
        指定查找多个模块的输入源文件的位置
  --module-version <版本>        指定正在编译的模块版本
  -nowarn                      不生成任何警告
  -parameters                  生成元数据以用于方法参数的反射
  -proc:{none,only}            控制是否执行注释处理和/或编译。
  -processor <class1>[,<class2>,<class3>...]
        要运行的注释处理程序的名称; 绕过默认的搜索进程
  --processor-module-path <path>
        指定查找注释处理程序的模块路径
  --processor-path <path>, -processorpath <path>
        指定查找注释处理程序的位置
  -profile <profile>           请确保使用的 API 在指定的配置文件中可用
  --release <release>          为指定的 Java SE 发行版编译。支持的发行版：7, 8, 9, 10, 11, 12, 13
  -s <directory>               指定放置生成的源文件的位置
  --source <release>, -source <release>
        提供与指定的 Java SE 发行版的源兼容性。支持的发行版：7, 8, 9, 10, 11, 12, 13
  --source-path <path>, -sourcepath <path>
        指定查找输入源文件的位置
  --system <jdk>|none          覆盖系统模块位置
  --target <release>, -target <release>
        生成适合指定的 Java SE 发行版的类文件。支持的发行版：7, 8, 9, 10, 11, 12, 13
  --upgrade-module-path <path>
        覆盖可升级模块位置
  -verbose                     输出有关编译器正在执行的操作的消息
  --version, -version          版本信息
  -Werror                      出现警告时终止编译

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.0</version>
    <configuration>
        <source>8</source>
        <target>8</target>
        <encoding>UTF-8</encoding>
        <compilerArgs>
            <compilerArgument>-g:lines</compilerArgument>
            <compilerArgument>-g:vars</compilerArgument>
            <compilerArgument>-g:source</compilerArgument>
            <compilerArgument>-verbose</compilerArgument>
        </compilerArgs>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.0</version>
    <configuration>
        <source>8</source>
        <target>8</target>
        <encoding>UTF-8</encoding>
        <compilerArgs>
            <compilerArgument>-g:none</compilerArgument>
        </compilerArgs>
    </configuration>
</plugin>

// idea 反编译结果
package bytecode;
public class PageClass {
    private static final int size = 10;
    private int page;
    public PageClass(int page) {
        this.page = page;
    }
    public int calculateOffset() {
        return this.page * 10;
    }
    public static void main(String[] args) {
        PageClass page = new PageClass(3);
        System.out.println(page.calculateOffset());
    }
}

// idea 反编译结果
package bytecode;
public class PageClass {
    private static final int size = 10;
    private int page;
    public PageClass(int var1) {
        this.page = var1;
    }
    public int calculateOffset() {
        return this.page * 10;
    }
    public static void main(String[] var0) {
        PageClass var1 = new PageClass(3);
        System.out.println(var1.calculateOffset());
    }
}

// jd-gui 反编译结果
package bytecode;
public class PageClass {
  private static final int size = 10;
  private int page; 
  public PageClass(int paramInt) { this.page = paramInt; }
  public int calculateOffset() { return this.page * 10; }
  public static void main(String[] paramArrayOfString) {
    PageClass pageClass = new PageClass(3);
    System.out.println(pageClass.calculateOffset());
  }
}

iload、iload_<n>
lload、lload_<n>
fload、fload_<n>
dload、dload_<n>
aload、aload_<n>

istore、istore_<n>
lstore、lstore_<n>
fstore、fstore_<n>
dstore、dstore_<n>
astore、astore_<n>

bipush、sipush
ldc、ldc_w、ldc2_w
aconst_null
iconst_m1、iconst_<i>、lconst_<l>、fconst_<f>、dconst_<d>

wide

加法指令：iadd、ladd、fadd、dadd。
减法指令：isub、lsub、fsub、dsub。
乘法指令：imul、lmul、fmul、dmul。
除法指令：idiv、ldiv、fdiv、ddiv。
求余指令：irem、lrem、frem、drem。
取反指令：ineg、lneg、fneg、dneg。
位移指令：ishl、ishr、iushr、lshl、lshr、lushr。
按位或指令：ior、lor。
按位与指令：iand、land。
按位异或指令：ixor、lxor。
局部变量自增指令：iinc。
比较指令：dcmpg、dcmpl、fcmpg、fcmpl、lcmp。

int --> long、float double
long --> float、double
float --> double

i2b、i2c、i2s、l2i、f2i、f2l、d2i、d2l和d2f。

创建类实例的指令：new
创建数组的指令：newarray、anewarray、multianewarray
访问类字段(static)的指令: getstatic、putstatic
访问实例字段（非static）的指令：getfield、putfield
把一个数组元素加载到操作数栈的指令：baload、caload、saload、iaload、laload、faload、daload、aaload
将一个操作数栈的值存储到数组元素中的指令：bastore、castore、sastore、iastore、fastore、dastore、aastore。
取数组长度的指令：arraylength。
检查类实例类型的指令：instanceof、checkcast。

将操作数栈的栈顶一个或两个元素出栈：pop、pop2。
复制栈顶一个或两个数值并将复制值或双份的复制值重新压入栈顶：dup、dup2、dup_x1、dup2_x1、dup_x2、dup2_x2。
将栈最顶端的两个数值互换：swap。

条件分支：ifeq、iflt、ifle、ifne、ifgt、ifge、
      ifnull、ifnonnull、
      if_icmpeq、if_icmpne、if_icmplt、if_icmpgt、if_icmple、
      if_icmpge、if_acmpeq、if_acmpne。
复合条件分支：tableswitch、lookupswitch。
无条件分支：goto、goto_w、jsr、jsr_w、ret。

Code {
  0 aload_0
  1 getfield #7 <bytecode/PageClass.page>
  4 bipush 10
  6 imul
  7 ireturn  
}

local_variable_tables[
  {
    u2 : 0000;  (start_pc : 0)
    u2 : 0008;  (length : 8)
    u2 : 0025;  (name_index，37-Utf8 : this)
    u2 : 0026;  (descriptor_index，38-Utf8 : Lbytecode/PageClass;)
    u2 : 0000;  (index : 0 , 第1个内部变量)
  }
]

PageClass page = new PageClass(3);
System.out.println(page.calculateOffset());

/**
 * 定义常量
 */
private static final int size = 10;


/**
 * 定义常量
 */
private static int size = 10;

0 aload_0
1 getfield #7 <bytecode/PageClass.page>
4 bipush 10
6 imul
7 ireturn	


0 aload_0
1 getfield #7 <bytecode/PageClass.page>
4 getstatic #13 <bytecode/PageClass.size>
7 imul
8 ireturn