关于java:Java-进阶-02-是时候了解一下-Java-字节码了

咱们平时所说的 Java 字节码，指的是用 Java 语言编译成的字节码。精确的说能在 JVM 平台上执行的字节码格局都是一样的。所以应该统称为 JVM 字节码。
不同的编译器，能够编译出雷同的字节码文件，字节码文件也能够在不同的 JVM 上运行。
Java 虚拟机与 Java 语言并没有必然的分割，它只与特定的二进制文件格式 .class 文件格式所关联，.class 文件中蕴含了 Java 虚拟机指令集（或者称为字节码、Bytecodes）和符号表，还有一些其余的辅助信息。
Java bytecode 由单字节（byte）的指令组成，实践上最多反对 256 个操作码（opcode）。实际上 Java 只应用了 200 左右的操作码，还有一些操作码则保留给调试操作。详情见：
JVM 指令集对照表

依据指令的性质，次要分为四个大类：

栈操作指令，包含与局部变量交互的指令
程序流程控制指令
对象操作指令，包含办法调用指令
算术运算以及类型转换指令

举个简略的例子：

public class HelloByteCode {public static void main(String[] args) {HelloByteCode obj = new HelloByteCode();
    }
}

$ javac -g HelloByteCode.java
$ javap -c -v HelloByteCode
Classfile /Users/yonghong/Coding/code-lab/gtu-java/week01/HelloByteCode.class
  Last modified 2021-1-7; size 415 bytes
  MD5 checksum 44dd68d97fffda0bd16a524fb32b983a
  Compiled from "HelloByteCode.java"
public class HelloByteCode
  minor version: 0
  major version: 52   // 52 对应 Java 8
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:        // 常量池
   #1 = Methodref          #4.#19         // java/lang/Object."<init>":()V
   #2 = Class              #20            // HelloByteCode
   #3 = Methodref          #2.#19         // HelloByteCode."<init>":()V
   #4 = Class              #21            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               LocalVariableTable
  #10 = Utf8               this
  #11 = Utf8               LHelloByteCode;
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               args
  #15 = Utf8               [Ljava/lang/String;
  #16 = Utf8               obj
  #17 = Utf8               SourceFile
  #18 = Utf8               HelloByteCode.java
  #19 = NameAndType        #5:#6          // "<init>":()V
  #20 = Utf8               HelloByteCode
  #21 = Utf8               java/lang/Object
{public HelloByteCode();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LHelloByteCode;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class HelloByteCode
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: return
      LineNumberTable:
        line 3: 0   // new 指令在源码的第 3 行
        line 4: 8   // return 指令在源码的第 4 行
      LocalVariableTable:   // 本地变量表
        Start  Length  Slot  Name   Signature
      // 起作用的行  失效范畴  槽数  变量名称  变量类型签名
            0       9     0  args   [Ljava/lang/String;
            8       1     1   obj   LHelloByteCode;
}
SourceFile: "HelloByteCode.java"

javac 的用法

$ javac -help
用法: javac <options> <source files>
其中, 可能的选项包含:
  -g                         生成所有调试信息
  -g:none                    不生成任何调试信息
  -g:{lines,vars,source}     只生成某些调试信息
  -nowarn                    不生成任何正告
  -verbose                   输入无关编译器正在执行的操作的音讯
  -deprecation               输入应用已过期的 API 的源地位
  -classpath < 门路 >            指定查找用户类文件和正文处理程序的地位
  -cp < 门路 >                   指定查找用户类文件和正文处理程序的地位
  -sourcepath < 门路 >           指定查找输出源文件的地位
  -bootclasspath < 门路 >        笼罩疏导类文件的地位
  -extdirs < 目录 >              笼罩所装置扩大的地位
  -endorseddirs < 目录 >         笼罩签名的规范门路的地位
  -proc:{none,only}          管制是否执行正文解决和 / 或编译。-processor <class1>[,<class2>,<class3>...] 要运行的正文处理程序的名称; 绕过默认的搜寻过程
  -processorpath < 门路 >        指定查找正文处理程序的地位
  -parameters                生成元数据以用于办法参数的反射
  -d < 目录 >                    指定搁置生成的类文件的地位
  -s < 目录 >                    指定搁置生成的源文件的地位
  -h < 目录 >                    指定搁置生成的本机标头文件的地位
  -implicit:{none,class}     指定是否为隐式援用文件生成类文件
  -encoding < 编码 >             指定源文件应用的字符编码
  -source < 发行版 >              提供与指定发行版的源兼容性
  -target < 发行版 >              生成特定 VM 版本的类文件
  -profile < 配置文件 >            请确保应用的 API 在指定的配置文件中可用
  -version                   版本信息
  -help                      输入规范选项的提要
  - A 关键字 [= 值]                  传递给正文处理程序的选项
  -X                         输入非标准选项的提要
  -J< 标记 >                     间接将 < 标记 > 传递给运行时零碎
  -Werror                    呈现正告时终止编译
  @< 文件名 >                     从文件读取选项和文件名

javap 的用法

$ javap -help
用法: javap <options> <classes>
其中, 可能的选项包含:
  -help  --help  -?        输入此用法音讯
  -version                 版本信息
  -v  -verbose             输入附加信息
  -l                       输入行号和本地变量表
  -public                  仅显示公共类和成员
  -protected               显示受爱护的 / 公共类和成员
  -package                 显示程序包 / 受爱护的 / 公共类
                           和成员 (默认)
  -p  -private             显示所有类和成员
  -c                       对代码进行反汇编
  -s                       输入外部类型签名
  -sysinfo                 显示正在解决的类的
                           零碎信息 (门路, 大小, 日期, MD5 散列)
  -constants               显示最终常量
  -classpath <path>        指定查找用户类文件的地位
  -cp <path>               指定查找用户类文件的地位
  -bootclasspath <path>    笼罩疏导类文件的地位

JVM 是一台基于栈的计算机器。

每个线程都有一个独属于本人的线程栈（JVM Stack），用于存储栈帧（Frame）。每一次办法调用，JVM 都会主动创立一个栈帧。栈帧由操作数栈，局部变量数组以及一个 Class 援用组成。Class 援用指向以后办法在运行时常量池中对应的 Class。

MovingAverage.java

public class MovingAverage {
    private int count = 0;
    private double sum = 0.0D;

    public void submit(double value) {
        this.count++;
        this.sum += value;
    }

    public double getAvg() {if (0 == this.count) {return sum;}
        return this.sum / this.count;
    }
}

LocalVaribleTest.java

public class LocalVaribleTest {public static void main(String[] args) {MovingAverage ma = new MovingAverage();
        int num1 = 1;
        int num2 = 2;
        ma.submit(num1);
        ma.submit(num2);
        double avg = ma.getAvg();}
}

$ javap -c MovingAverage
Compiled from "MovingAverage.java"
public class MovingAverage {public MovingAverage();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_0
       6: putfield      #2                  // Field count:I
       9: aload_0
      10: dconst_0
      11: putfield      #3                  // Field sum:D
      14: return

  public void submit(double);
    Code:
       0: aload_0
       1: dup
       2: getfield      #2                  // Field count:I
       5: iconst_1
       6: iadd
       7: putfield      #2                  // Field count:I
      10: aload_0
      11: dup
      12: getfield      #3                  // Field sum:D
      15: dload_1
      16: dadd
      17: putfield      #3                  // Field sum:D
      20: return

  public double getAvg();
    Code:
       0: iconst_0
       1: aload_0
       2: getfield      #2                  // Field count:I
       5: if_icmpne     13
       8: aload_0
       9: getfield      #3                  // Field sum:D
      12: dreturn
      13: aload_0
      14: getfield      #3                  // Field sum:D
      17: aload_0
      18: getfield      #2                  // Field count:I
      21: i2d
      22: ddiv
      23: dreturn
}

$ javap -c LocalVaribleTest
Compiled from "LocalVaribleTest.java"
public class LocalVaribleTest {public LocalVaribleTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class MovingAverage
       3: dup
       4: invokespecial #3                  // Method MovingAverage."<init>":()V
       7: astore_1
       8: iconst_1
       9: istore_2
      10: iconst_2
      11: istore_3
      12: aload_1
      13: iload_2
      14: i2d   // int 转成 double 隐式转换
      15: invokevirtual #4                  // Method MovingAverage.submit:(D)V
      18: aload_1
      19: iload_3
      20: i2d
      21: invokevirtual #4                  // Method MovingAverage.submit:(D)V
      24: aload_1
      25: invokevirtual #5                  // Method MovingAverage.getAvg:()D
      28: dstore        4
      30: return
}

public class ForLoopTest {private static int[] nums = {1, 6, 8};
    public static void main(String[] args) {MovingAverage ma = new MovingAverage();
        for (int num : nums) {ma.submit(num);
        }
        double avg = ma.getAvg();}
}

$ javap -c ForLoopTest
Compiled from "ForLoopTest.java"
public class ForLoopTest {public ForLoopTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class MovingAverage
       3: dup
       4: invokespecial #3                  // Method MovingAverage."<init>":()V
       7: astore_1
       8: getstatic     #4                  // Field nums:[I
      11: astore_2
      12: aload_2
      13: arraylength
      14: istore_3
      15: iconst_0                // 初始化变量 0
      16: istore        4         // 存储到本地变量表 4 槽位
      18: iload         4         // 加载 4 槽位 到操作数栈
      20: iload_3                 // 加载 int 3 到操作数栈
      21: if_icmpge     43        // 比拟，如果大于等于跳转到 43 行指令
      24: aload_2
      25: iload         4
      27: iaload
      28: istore        5
      30: aload_1
      31: iload         5
      33: i2d
      34: invokevirtual #5                  // Method MovingAverage.submit:(D)V
      37: iinc          4, 1      // 4 槽位上加 1
      40: goto          18        // goto 18 行指令
      43: aload_1
      44: invokevirtual #6                  // Method MovingAverage.getAvg:()D
      47: dstore_2
      48: return

  static {};
    Code:
       0: iconst_3
       1: newarray       int
       3: dup
       4: iconst_0
       5: iconst_1
       6: iastore
       7: dup
       8: iconst_1
       9: bipush        6
      11: iastore
      12: dup
      13: iconst_2
      14: bipush        8
      16: iastore
      17: putstatic     #4                  // Field nums:[I
      20: return
}

invokestatic，顾名思义，这个指令用于调用某个类的静态方法，这是办法调用指令中最快的一个。
invokespecial, 用来调用构造函数，但也能够用于调用同一个类中的 private 办法, 以及可见的超类办法。
invokevirtual，如果是具体类型的指标对象，invokevirtual 用于调用公共，受爱护和 package 级的公有办法。
invokeinterface，当通过接口援用来调用办法时，将会编译为 invokeinterface 指令。
invokedynamic，JDK7 新减少的指令，是实现“动静类型语言”（Dynamically Typed Language）反对而进行的降级改良，同时也是 JDK8 当前反对 lambda 表达式的实现根底。

关于java:Java-进阶-02-是时候了解一下-Java-字节码了

什么是字节码？

javac 与 javap

字节码的运行时构造

从助记符到二进制

四则运行的例子

算数操作与类型转换

一个残缺的循环管制

办法调用的指令