javap淺析-書籍第3章的手寫稿樣稿

胖哥為什麼要給簡單程序呢？為啥不直接來個複雜的程序呢？

答曰：javap命令工具輸出的內容是繁雜的，即使是一段小程序輸出後，結果也比原始代碼要複雜很多。我們要學的其實並不是說看指令就能完全反轉為Java代碼，把自己當成一個“反編譯工具”（除非你真的已經很牛了，自然本書接下來的內容也不適合你），要學會的是通過這種方式可以認知比Java更低一個抽象層次的邏輯，或許有許多問題直接用Java代碼不好解釋，但是一旦看到虛指令後就一切明了。

在本節，胖哥分別演示String的小代碼，和幾段數字處理的小程序（延續下第1章的數字遊戲）。

D:\java_A>javac –g:vars,lines chapter01/StringTest.java

D:\java_A>javap -verbose chapter01.StringTest

public class chapter01.StringTest extends java.lang.Object

  minor version: 0

  major version: 50

  Constant pool:

const #1 = Method       #6.#21; //  java/lang/Object."<init>":()V

const #2 = String       #22;    //  ab1

const #3 = Field        #23.#24;        //  java/lang/System.out:Ljava/io/PrintStream;

const #4 = Method      #25.#26;        //  java/io/PrintStream.println:(Z)V

const #5 = class        #27;    //  chapter01/StringTest

const #6 = class        #28;    //  java/lang/Object

const #7 = Asciz        <init>;

const #8 = Asciz        ()V;

const #9 = Asciz        Code;

const #10 = Asciz       LineNumberTable;

const #11 = Asciz       LocalVariableTable;

const #12 = Asciz       this;

const #13 = Asciz       Lchapter01/StringTest;;

const #14 = Asciz       test1;

const #15 = Asciz       a;

const #16 = Asciz       Ljava/lang/String;;

const #17 = Asciz       b;

const #18 = Asciz       StackMapTable;

const #19 = class       #29;    //  java/lang/String

const #20 = class       #30;    //  java/io/PrintStream

const #21 = NameAndType #7:#8;//  "<init>":()V

const #22 = Asciz       ab1;

const #23 = class       #31;    //  java/lang/System

const #24 = NameAndType #32:#33;//  out:Ljava/io/PrintStream;

const #25 = class       #30;    //  java/io/PrintStream

const #26 = NameAndType #34:#35;//  println:(Z)V

const #27 = Asciz       chapter01/StringTest;

const #28 = Asciz       java/lang/Object;

const #29 = Asciz       java/lang/String;

const #30 = Asciz       java/io/PrintStream;

const #31 = Asciz       java/lang/System;

const #32 = Asciz       out;

const #33 = Asciz       Ljava/io/PrintStream;;

const #34 = Asciz       println;

const #35 = Asciz       (Z)V;

{

public chapter01.StringTest();

  Code:

   Stack=1, Locals=1, Args_size=1

   0:   aload_0

   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V

   4:   return

  LineNumberTable:

   line 4: 0

  LocalVariableTable:

   Start  Length  Slot  Name   Signature

   0      5      0    this       Lchapter01/StringTest;

public static void test1();

  Code:

   Stack=3, Locals=2, Args_size=0

   0:   ldc     #2; //String ab1

   2:   astore_0

   3:   ldc     #2; //String ab1

   5:   astore_1

   6:   getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;

   9:   aload_0

   10:  aload_1

   11:  if_acmpne       18

   14:  iconst_1

   15:  goto    19

   18:  iconst_0

   19:  invokevirtual   #4; //Method java/io/PrintStream.println:(Z)V

   22:  return

  LineNumberTable:

   line 7: 0

   line 8: 3

   line 9: 6

   line 10: 22

  LocalVariableTable:

   Start  Length  Slot  Name   Signature

   3      20      0    a       Ljava/lang/String;

   6      17      1    b       Ljava/lang/String;

  StackMapTable: number_of_entries = 2

   frame_type = 255 /* full_frame */

     offset_delta = 18

     locals = [ class java/lang/String, class java/lang/String ]

     stack = [ class java/io/PrintStream ]

   frame_type = 255 /* full_frame */

     offset_delta = 0

     locals = [ class java/lang/String, class java/lang/String ]

     stack = [ class java/io/PrintStream, int ]

}

例子1：

const #1 = Method       #6.#21; //  java/lang/Object."<init>":()V

入口位置#1，簡稱入口#1，代表一個方法入口，方法入口由：入口#6 和 入口#21兩者一起組成，中間用了一個“.”。

const #6 = class        #28;    //  java/lang/Object

const #21 = NameAndType #7:#8;//  "<init>":()V

入口#6為一個class，class是一種引用，所以它引用了入口#28的常量池。

入口#21 代表一個表示名稱和類型（NameAndType），分別由入口#7和入口#8組成。

const #7 = Asciz        <init>;

const #8 = Asciz        ()V;

const #28 = Asciz       java/lang/Object;

入口#7是一個常量池內容，<init>;代表構造方法的意思。

入口#8 也是一個真正的常量，值為()V，代表沒有入口參數，返回值為void，將入口#7和入口#8反推到入口#21，就代表名稱為構造方法的名稱，入口參數個數為0，返回值為void的意思。

入口#28是一個常量，它的值是“java/lang/Object;”，但這隻是一個字符串值，反推到入口#6，要求這個字符串代表的是一個類，那麼自然代表的類是java.lang.Object。

綜合起來就是：java.lang.Object類的構造方法，入口參數個數為0，返回值為void，其實這在const #1後麵的備注中已經標識出來了（這在字節碼中本身不存在，隻是javap工具幫助合並的）。

例子2：

const #2 = String       #22;    //  ab1

它代表將會有一個String類型的引用入口，而引用的是入口#22的內容。

const #22 = Asciz       ab1;

這裏代表常量池中會存放內容ab1。

綜合起來就是：一個String對象的常量，存放的值是ab1。

例子3（稍微複雜一點）：

const #3 = Field        #23.#24;        //  java/lang/System.out:Ljava/io/PrintStream;

const #4 = Method      #25.#26;        //  java/io/PrintStream.println:(Z)V

入口#3代表一個屬性，這個屬性引用了入口#23的類，入口#24的具體屬性。

入口#4代表一個方法，引用了入口#25的類，入口#26的具體方法。

const #23 = class       #31;    //  java/lang/System

const #24 = NameAndType #32:#33;//  out:Ljava/io/PrintStream;

const #25 = class       #30;    //  java/io/PrintStream

const #26 = NameAndType #34:#35;//  println:(Z)V

入口#23 代表一個類（class），它也是一個引用，它引用了入口#31的常量。

入口#24 代表一個名稱和類型（NameAndType），分別對應入口#32:#33。

入口 #25 代表一個class類的引用，具體引用到入口#30。

入口 #26 與入口#24類似，也是一個返回值+引用類型對應入口#34:#35。

const #30 = Asciz       java/io/PrintStream;

const #31 = Asciz       java/lang/System;

const #32 = Asciz       out;

const #33 = Asciz       Ljava/io/PrintStream;;

const #34 = Asciz       println;

const #35 = Asciz       (Z)V;

入口#30 對應常量池的值為：java/io/PrintStream;反推到入口#25，自然代表類java.lang.PrintStream。

入口#31對應常量池的值為：java/lang/System;反推到入口#23，代表類：java.lang.System。

入口#32 對應常量池的值為：out;反推到入口#24，而入口#24要求名稱和類型，這裏返回的顯然是名稱。

入口#33 對應常量池的值為：Ljava/io/PrintStream;; 反推到入口#24這裏得到了類型，也就是out的類型是java.io.PrintStream。

入口#34 對應常量池的值為：println;反推到入口#26代表名稱為println。

入口#35 對應常量池的值為：(Z)V;反推到入口#26代表入口參數為Z（代表boolean類型），返回值類型是V（代表void）

綜合來講要執行的操作就是：

入口#3是獲取到java/lang/System類的屬性out，out的類型是Ljava/io/PrintStream;

入口#4是調用java/io/PrintStream類的println方法，方法的返回值類型是void，入口類型是boolean。

public chapter01.StringTest();

  Code:

   Stack=1, Locals=1, Args_size=1

   0:   aload_0

   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V

   4:   return

  LineNumberTable:

   line 4: 0

  LocalVariableTable:

   Start  Length  Slot  Name   Signature

   0      5      0    this       Lchapter01/StringTest;

Stack=1, Locals=1, Args_size=1

這一行是所有的方法都會有的，其中Stack代表棧頂的單位大小（每一個大小為一個solt的大小，每個solt是4個字節的寬度），當一個數據需要使用時首先會被放入到棧頂，使用完後會寫回到本地變量或主存中。這裏的棧的寬度是1，其實是代表有一個this將會被使用。

Locals是本地變量的slot個數，但是並不代表是stack寬度一致，本地變量是在這個方法生命周期內，局部變量最多的時候，需要多大的寬度來存放數據（double、long會占用兩個slot）。

Args_size代表的是入參的個數，不再是slot的個數，也就是傳入一個long，也隻會記錄1。

0:   aload_0

首先第一個0代表虛指令中的行號（後麵會應到，確切說應該是方法的body部分第幾個字節），每個方法從0開始順序遞增，但是可以跳躍，跳躍的原因在於一些指令還會接操作的內容，這些操作的內容可能來自常量池，也可以標誌是第幾個slot的本地變量，因此需要占用一定的空間。

aload_0指令是將“第1個”slot所在的本地變量推到棧頂，並且這個本地變量是引用類型的，相關的指令有：aload_[0-3]（範圍是：0x2a ~ 0x2d）。如果超過4個，則會使用“aload + 本地變量的slot位置”來完成（此時會多占用1個字節來存放），前者是通過具體的幾個指令直接完成。

許多地方會解釋為第1個引用類型的本地變量，但胖哥是一個邏輯怪，認為這句話有問題，並不是第1個引用變量，普通變量如果在它之前，它也不是第1個了，此時本身就是第1個本地變量，更確切地說是第一個slot所在位置的本地變量。

1:   invokespecial   #1; //Method java/lang/Object."<init>":()V

指令中的第2個行號，執行invokespecial指令，這個指令是當發生構造方法調用、父類的構造方法調用、非靜態的private方法調用會使用該指令，這裏需要從常量池中獲取一個方法，這個地方會占用2個字節的寬度，加上指令本身就是3個字節，因此下一個行號是4。

4:   return

最後一行是一個return，我們雖然沒有自己寫return，但是JVM中會自動在編譯時加上。

LocalVariableTable:

   Start  Length  Slot  Name   Signature

   0      5      0    this       Lchapter01/StringTest;

代表本地變量的列表，這裏代表本地變量的作用域起始位置為0，作用域寬度為5（0-4），slot的起始位置也是0，名稱為this，類型為chapter01.StringTest。

public static void test1();

  Code:

   Stack=3, Locals=2, Args_size=0

//Stack=3代表本地棧slot個數為3，兩個String需要load，System的out也會占用一個，當發生對比生成boolean的時候，會將兩個String的引用從棧頂pop出來，所以棧最多3個slot

//Locals為2，因為隻有兩個String

//如果是非靜態方法本地變量會自動增加this.

//Args_size為0代表這個方法沒有任何入口參數

   0:   ldc     #2; //String ab1

   //指令body部分從第0個字節為Idc指令，從常量池入口#2中取出內容推到棧頂

   //這裏的String也是引用，但是它是常量，所以是用Idc指令，不是aload指令

   2:   astore_0

   //將棧頂的引用值，寫入第1個slot所在的本地變量中。

//它與aload指令正好相反,對應astore_[0-3]（範圍是0x4b、0x4e）

//更多的本地引用變量寫入則使用atore + 引用變量的slot位置。

   3:   ldc     #2; //String ab1

   //與第0行一致的操作，引用常量池入口#2來獲得

   5:   astore_1

   //類似第2行，將棧頂的值賦值給第2個slot位置的本地引用變量。

   6:   getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;

   //獲取靜態域，放入棧頂，引用了常量池入口#3來獲得

   //此時的靜態區域是System類中的out對象

   9:   aload_0

   //將第1個slot所在位置的本地引用變量加載到棧頂

   10:  aload_1

   //將第二個slot所在位置的本地引用變量加載到棧頂

   11:  if_acmpne       18

   14:  iconst_1

   15:  goto    19

   18:  iconst_0

   //判定兩個棧頂的引用是否一致（引用值也就是地址），對比處理的結束位置是18行

   // if_acmpne操作之前會先將兩個操作數從棧頂pop出來，因此棧頂最多3位

   //如果一致則將常量值1寫入到棧頂，也就是對應到boolean值true，並跳轉到19行

//如果不一致則將常量值0寫入到棧頂，對應到boolean值false

   19:  invokevirtual   #4; //Method java/io/PrintStream.println:(Z)V

   //執行out對象的println方法，方法的入口參數是boolean類型，返回值是void。

   //從常量池入口#4獲得方法的內容實體。

//此時會將棧頂的元素當成入口參數，棧頂的0或1則會轉換為boolean值的true、false。

   22:  return

  LineNumberTable:

   line 7: 0

   line 8: 3

   line 9: 6

   line 10: 22

  //對應源文件行號，左邊的是字節碼的位置（也可以叫做行號），右邊的是源文件中的實際文本行號

  //javac編譯默認有這個內容，但是如果-g:none則不會產生，那麼調試就會有問題

  LocalVariableTable:

   Start  Length  Slot  Name   Signature

   3      20      0    a       Ljava/lang/String;

   6      17      1    b       Ljava/lang/String;

  //本地變量列表，javac中需要使用-g:vars才會生成，使用一些工具會自動生成，若沒有，則調試的時候，斷點中看到的變量是沒有名稱的。

  //第一個本地變量的作用區域從第3個字節的位置開始，作用區域範圍為20個字節，所在slot的位置是第0個位置，名稱為a，類型為java.lang.String。

//第二個本地變量也是類似的方式可以得到結果。

public static void test() {

        int a = 1 , b = 1 , c = 1 , d = 1;

        a++;

        ++b;

        c = c++;

        d = ++d;

       System.out.println(a + "\t" + b + "\t" + c + "\t" + d);

    }

2   2   1   2

public static void test();

  Code:

   Stack=3, Locals=4, Args_size=0

   0:   iconst_1  //將int類型常量值1推送到棧頂

   1:   istore_0  //將棧頂拋出賦值給第1個slot所在的int類型本的變量中

   2:   iconst_1  //與第0行一致

   3:   istore_1  //將棧頂拋出賦值給第2個slot所在的int類型本的變量中

   4:   iconst_1  //與第0行一致

   5:   istore_2  //將棧頂拋出賦值給第3個slot所在的int類型本的變量中

   6:   iconst_1  //與第0行一致

   7:   istore_3  //將棧頂拋出賦值給第4個slot所在的int類型本的變量中

   8:   iinc    0, 1  //將第1個slot所在的int類型本的變量自加1

   11:  iinc    1, 1  //將第2個slot所在的int類型本的變量自加1

   14:  iload_2  //將第3個slot所在的int類型本的變量放入棧頂

   15:  iinc    2, 1 //將第3個slot所在的int類型本的變量加1

   18:  istore_2  //從棧頂拋出數據寫入到第3個slot所在的int類型本的變量

   19:  iinc    3, 1 //將第4個slot位置所在的int類型的本變量自增1

   22:  iload_3  //將第4個slot位置所在的int類型的本地變量加載到棧頂

   23:  istore_3  //將棧頂數據拋出，寫入到第4個slot所在的int類型的本地變量中

  LocalVariableTable:

   Start  Length  Slot  Name   Signature

   2      70      0    a       I //本地變量a，類型int，作用域第2行開始，作用域範圍70行

   4      68      1    b       I//本地變量b，類型int，作用域第4行開始，作用域範圍68行

   6      66      2    c       I//本地變量c，類型int，作用域第6行開始，作用域範圍66行

   8      64      3    d       I//本地變量d，類型int，作用域第8行開始，作用域範圍64行

24:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;

27:  new     #3; //class java/lang/StringBuilder

30:  dup

31:  invokespecial   #4; //Method java/lang/StringBuilder."<init>":()V

34:  iload_0

35:  invokevirtual   #5; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;

38:  ldc     #6; //String \t

40:  invokevirtual #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

43:  iload_1

44:  invokevirtual   #5; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;

47:  ldc     #6; //String \t

49:  invokevirtual #7; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

52:  iload_2

53:  invokevirtual   #5; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;

56:  ldc     #6; //String \t

58:  invokevirtual #7;//Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

61:  iload_3

62:  invokevirtual   #5; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;

65:  invokevirtual   #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;

68:  invokevirtual   #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V

71:  return

大家可以在這段代碼上做幾個小改動，進一步分析：

○ 將拚接過程換成一個StringBuilder，看看Stacks的數量有沒有變化。

○ 換成一個StringBuilder在一行代碼中append多個變量，與分成多行分別append，指令上是否有區別（這裏append的內容有7個，你完全可以拆分2、3個出來看看）。

○ 添加一個自定義對象，自定義對象中有一個void返回值的方法，也像append那樣反複調用，看看它是不是需要每次iload，而StringBuilder不需要。其實為什麼我們已經解釋過了，接下來就靠大家自己去擴展了哦。