Java 常量池详解（一）字符串常量池

2.class文件常量池（class constant pool）

产生时机：当java文件被编译成class文件之后，就会生成class常量池，跟jvm 无关系

常量池主要存放两大类常量：字面量；符号引用

在这里插入图片描述

字面量接近Java语言层面的常量概念，如文本字符串、声明为final的常量值等

(Integer、 Float 、Long、 Double、 String、 UTF-8)

符号引用包含三类引用:
1、类和接口的全限定名 org.springframework…Bean
举例：jvm/Hotspot/ConstantsTest

 #7 = Class              #41            // jvm/Hotspot/ConstantsTest#41 = Utf8               jvm/Hotspot/ConstantsTest

2、字段的名称和描述符
举例： int b

 #4 = Fieldref           #7.#37         // jvm/Hotspot/ConstantsTest.b:I#7 = Class              #41            // jvm/Hotspot/ConstantsTest#37 = NameAndType        #17:#18        // b:I#41 = Utf8               jvm/Hotspot/ConstantsTest#17 = Utf8               b#18 = Utf8               I

3、方法的名称和描述符
举例：int getB()

 #9 = Methodref          #7.#42          // jvm/Hotspot/ConstantsTest.getB:()I#7 = Class              #41            // jvm/Hotspot/ConstantsTest#42 = NameAndType        #26:#27        // getB:()I #41 = Utf8               jvm/Hotspot/ConstantsTest#26 = Utf8               getB#27 = Utf8               ()I

Class 文件布局如下（跟方法区布局息息相关的）

在这里插入图片描述

public class ConstantsTest {private static Integer a = 10;private int b;private String c = "cc";private static String d = "dd";public int getB() {return b;}public static int getA() {return a;}public static void main(String[] args) {ConstantsTest constantsTest = new ConstantsTest();constantsTest.getB();ConstantsTest.getA();}
}

//执行下面这个语句
javap -c -v -p ConstantsTest.class 得到

public class jvm.Hotspot.ConstantsTestminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #14.#34        // java/lang/Object."<init>":()V#2 = String             #35            // cc#3 = Fieldref           #7.#36         // jvm/Hotspot/ConstantsTest.c:Ljava/lang/String;#4 = Fieldref           #7.#37         // jvm/Hotspot/ConstantsTest.b:I#5 = Fieldref           #7.#38         // jvm/Hotspot/ConstantsTest.a:Ljava/lang/Integer;#6 = Methodref          #39.#40        // java/lang/Integer.intValue:()I#7 = Class              #41            // jvm/Hotspot/ConstantsTest#8 = Methodref          #7.#34         // jvm/Hotspot/ConstantsTest."<init>":()V#9 = Methodref          #7.#42         // jvm/Hotspot/ConstantsTest.getB:()I#10 = Methodref          #7.#43         // jvm/Hotspot/ConstantsTest.getA:()I#11 = Methodref          #39.#44        // java/lang/Integer.valueOf:(I)Ljava/lang/Integer;#12 = String             #45            // dd#13 = Fieldref           #7.#46         // jvm/Hotspot/ConstantsTest.d:Ljava/lang/String;#14 = Class              #47            // java/lang/Object#15 = Utf8               a#16 = Utf8               Ljava/lang/Integer;#17 = Utf8               b#18 = Utf8               I#19 = Utf8               c#20 = Utf8               Ljava/lang/String;#21 = Utf8               d#22 = Utf8               <init>#23 = Utf8               ()V#24 = Utf8               Code#25 = Utf8               LineNumberTable#26 = Utf8               getB#27 = Utf8               ()I#28 = Utf8               getA#29 = Utf8               main#30 = Utf8               ([Ljava/lang/String;)V#31 = Utf8               <clinit>#32 = Utf8               SourceFile#33 = Utf8               ConstantsTest.java#34 = NameAndType        #22:#23        // "<init>":()V#35 = Utf8               cc#36 = NameAndType        #19:#20        // c:Ljava/lang/String;#37 = NameAndType        #17:#18        // b:I#38 = NameAndType        #15:#16        // a:Ljava/lang/Integer;#39 = Class              #48            // java/lang/Integer#40 = NameAndType        #49:#27        // intValue:()I#41 = Utf8               jvm/Hotspot/ConstantsTest#42 = NameAndType        #26:#27        // getB:()I#43 = NameAndType        #28:#27        // getA:()I#44 = NameAndType        #50:#51        // valueOf:(I)Ljava/lang/Integer;#45 = Utf8               dd#46 = NameAndType        #21:#20        // d:Ljava/lang/String;#47 = Utf8               java/lang/Object#48 = Utf8               java/lang/Integer#49 = Utf8               intValue#50 = Utf8               valueOf#51 = Utf8               (I)Ljava/lang/Integer;
{private static java.lang.Integer a;descriptor: Ljava/lang/Integer;flags: ACC_PRIVATE, ACC_STATICprivate int b;descriptor: Iflags: ACC_PRIVATEprivate java.lang.String c;descriptor: Ljava/lang/String;flags: ACC_PRIVATEprivate static java.lang.String d;descriptor: Ljava/lang/String;flags: ACC_PRIVATE, ACC_STATICpublic jvm.Hotspot.ConstantsTest();descriptor: ()Vflags: ACC_PUBLICCode:stack=2, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>":()V4: aload_05: ldc           #2                  // String cc7: putfield      #3                  // Field c:Ljava/lang/String;10: returnLineNumberTable:line 10: 0line 13: 4public int getB();descriptor: ()Iflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: getfield      #4                  // Field b:I4: ireturnLineNumberTable:line 17: 0public static int getA();descriptor: ()Iflags: ACC_PUBLIC, ACC_STATICCode:stack=1, locals=0, args_size=00: getstatic     #5                  // Field a:Ljava/lang/Integer;3: invokevirtual #6                  // Method java/lang/Integer.intValue:()I6: ireturnLineNumberTable:line 21: 0public static void main(java.lang.String[]);descriptor: ([Ljava/lang/String;)Vflags: ACC_PUBLIC, ACC_STATICCode:stack=2, locals=2, args_size=10: new           #7                  // class jvm/Hotspot/ConstantsTest3: dup4: invokespecial #8                  // Method "<init>":()V7: astore_18: aload_19: invokevirtual #9                  // Method getB:()I12: pop13: invokestatic  #10                 // Method getA:()I16: pop17: returnLineNumberTable:line 25: 0line 26: 8line 27: 13line 28: 17static {};descriptor: ()Vflags: ACC_STATICCode:stack=1, locals=0, args_size=00: bipush        102: invokestatic  #11                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;5: putstatic     #5                  // Field a:Ljava/lang/Integer;8: ldc           #12                 // String dd10: putstatic     #13                 // Field d:Ljava/lang/String;13: returnLineNumberTable:line 11: 0line 14: 8
}

3.class运行时常量池

在这里插入图片描述

Class运行时常量池其实是当类加载到内存中后，jvm就会将class常量池中的内容存放到运行时常量池中。 里面放的也是符号引用和字面量，跟我们的class文件常量池放的东西是一样的

可以把Class文件常量池看作静态常量池（里面是符号引用），而运行时常量池是动态常量池（里面有直接引用），他俩是同一个东西，只是状态时机不同而已。

问题：Class 文件信息是否能跟方法区对应上来？

发现是能跟够一一对应的上的。方法区其实就可以简单看成运行状态的Class文件的布局

在这里插入图片描述

1. 符号引用(脱离jvm 体系来讲，就单纯class文件的符号引用而已）

符号引用以一组符号来描述所引用的目标，在编译的时候一个每个java类都会被编译成一个class文件， 但在编译的时候虚拟机并不知道所引用类的地址，多以就用符号引用来代替 ，而在这个解析阶段就是为了把这个符号引用转化成为真正的地址的阶段

比如：class 文件里面有个方法调用getB()方法。还没到准备阶段（虚拟机就会进入准备阶段。在这个阶段，虚拟机就会为这个类分配相应的内存空间，并设置默认初始值）。是不知道具体new 对象所在的地址的。class 文件里面只是符号引用，知道是用这个类的方法。

 public static void main(String[] args) {ConstantsTest constantsTest = new ConstantsTest();constantsTest.getB();
}
//对应的反编译 代码其实 是
9: invokevirtual #9                  // Method getB:()I但其实#9 是常量池里面的 // jvm/Hotspot/ConstantsTest.getB:()I

2.直接引用

直接引用和虚拟机的布局是相关的如果有了直接引用，那么直接引用的目标一定被加载到了内存中。（有具体引用地址的指针，被引用的类、方法或者变量已经被加载到内存中）

3.静态链接

当一个字节码文件被装载进 JVM 内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接

比如：调用静态方法, 调用实例的私有构造器, 私有方法, 父类方法，被final修饰的方法（其实就是不能被子类重写的方法，能确定唯一性）

4.动态链接

如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接。

比如：（B b = new B2() ) 父类声明，子类实现的情况，方法被子类重写了。

案例分析

有一个父类B 和子类B2 ，子类B2实现了B的getA 方法

public class B {private int a = 2;public int getA() {return a;}public static void print() {System.out.println("aaa");}public final void b() {}private void c() {System.out.println("c");}
}//只能重写getA方法
public class B2 extends B {@Overridepublic int getA() {return 2;
}

此时有个线程调用了声明为B ，但是实现为B2的方法

public static void main(String[] args) {B b2 = new B2();b2.getA();b2.b();
}

class文件编译结果如下：

0: new           #4                  // class jvm/Hotspot/B2
3: dup
4: invokespecial #5                  // Method jvm/Hotspot/B2."<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #2                  // Method jvm/Hotspot/B.getA:()I
12: pop
13: aload_1
14: invokevirtual #6                  // Method jvm/Hotspot/B.b:()V
17: return

此时这个 b2.getA() 他是动态链接，他只有在运行期间才知道用了具体哪个类，因为他这个方法可以被重写了，他可以是B类的getA方法，也可以是B2的get方法。此时这个 b2.b() 他是静态链接，他在编译期就确定是B类的b方法，是可以直接引用的

问题：动态链接跟什么有关系？

动态链接在栈帧里面，不会在停留在方法区里面，是跟线程有关系的
在这里插入图片描述

public class A {int a = 1;public int getA() {return a;}
}public class A2 extends A {@Overridepublic int getA() {return 10;}
}public class B {public int getB(A a) {return a.getA();}
}public class B2 extends B {@Overridepublic int getB(A a) {return a.getA()+1;}
}

线程调用

public static void main(String[] args) {B b2 = new B2();A a2 = new A2();b2.getB(a2);
}//java反编译之后得到
0: new           #2                  // class jvm/Hotspot/B2
3: dup
4: invokespecial #3                  // Method jvm/Hotspot/B2."<init>":()V
7: astore_1
8: new           #4                  // class jvm/Hotspot/A2
11: dup
12: invokespecial #5                  // Method jvm/Hotspot/A2."<init>":()V
15: astore_2
16: aload_1
17: aload_2
18: invokevirtual #6          // Method jvm/Hotspot/B.getB:(Ljvm/Hotspot/A;)I
21: pop
22: return