要注意的是，字符串常量池在JVM中只有一个，而运行时常量池是和类型数据绑定的，每个Class一个。

1. 每个class的字节码文件中都有一个常量池，里面是编译后即知的该class会用到的字面量与符号引用，这就是class文件常量池。JVM加载class，会将其类信息，包括class文件常量池置于方法区中。
2. class类信息及其class文件常量池是字节码的二进制流，它代表的是一个类的静态存储结构，JVM加载类时，需要将其转换为方法区中的java.lang.Class类的对象实例；同时，会将class文件常量池中的内容导入运行时常量池。
3. 运行时常量池中的常量对应的内容只是字面量，比如一个"字符串"，它还不是String对象；当Java程序在运行时执行到这个"字符串"字面量时，会去字符串常量池里找该字面量的对象引用是否存在，存在则直接返回该引用，不存在则在Java堆里创建该字面量对应的String对象，并将其引用置于字符串常量池中，然后返回该引用。
4. Java的基本数据类型中，除了两个浮点数类型，其他的基本数据类型都在各自内部实现了常量池，但都在[-128~127]这个范围内。

栈帧由三部分组成：局部变量区、操作数栈、帧数据区。

• 局部变量区是一个数组结构，主要存放对应方法的参数和局部变量。
• 如果是实例方法，局部变量表第一个参数是一个 reference 引用类型，存放的是当前对象本身 this。

• 操作数栈也是一个数组结构，但并不是通过索引来访问的，而是栈的压栈和出栈操作。
• 操作数栈是虚拟机的工作区，大多数指令都要从这里弹出数据、执行运算、然后把结果压回操作数栈。

• 每个栈帧内部都包含一个指向当前方法所在类型的运行时常量池的引用，以便对当前方法的代码实现动态链接。
• 在class文件里面，一个方法若要调用其他方法，或者访问成员变量，则需要通过符号引用来表示，动态链接的作用就是将这些以符号引用所表示的方法转换为对实际方法的直接引用。

• 方法执行后，有两种方式退出该方法：正常调用完成，执行返回指令。异常调用完成，遇到未捕获异常，不会有方法返回值给调用者。

1. 在局部变量表中创建一个局部变量o。
2. 在堆内存中分配一块内存地址，用来存储object对象。
3. 变量o指向堆内存中的内存地址。

在这个例子中，看到了常量池的出现，看来，还有必要了解一下常量池的知识

• 字面量：字面量主要是文本字符串、final 常量值、类名和方法名的常量等。
• 符号引用：符号引用对Java动态连接起着非常重要的作用。主要的符号引用有：类和接口的全限定名、字段的名称和描述符、方法的名称和描述符等。

class ConstantExample{
    private int value = 1;
    public String s = "abc";
    public final static int f = 0x101;
    public void setValue(int v){
        final int temp = 3;
        this.value = temp + v;
    }
    public int getValue(){
        return value;
    }
}

example/target/classes/HelloExample.class
  Last modified 2021-10-25; size 734 bytes
  MD5 checksum fd06c1426f4fdef12aa109ee7f010a45
  Compiled from "HelloExample.java"
public class HelloExample
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#32         // java/lang/Object."<init>":()V
   #2 = Fieldref           #5.#33         // HelloExample.value:I
   #3 = String             #34            // abc
   #4 = Fieldref           #5.#35         // HelloExample.s:Ljava/lang/String;
   #5 = Class              #36            // HelloExample
   #6 = Class              #37            // java/lang/Object
   #7 = Utf8               value
   #8 = Utf8               I
   #9 = Utf8               s
  #10 = Utf8               Ljava/lang/String;
  #11 = Utf8               f
  #12 = Utf8               ConstantValue
  #13 = Integer            257
  #14 = Utf8               <init>
  #15 = Utf8               ()V
  #16 = Utf8               Code
  #17 = Utf8               LineNumberTable
  #18 = Utf8               LocalVariableTable
  #19 = Utf8               this
  #20 = Utf8               LHelloExample;
  #21 = Utf8               getValue
  #22 = Utf8               ()I
  #23 = Utf8               setValue
  #24 = Utf8               (I)V
  #25 = Utf8               MethodParameters
  #26 = Utf8               main
  #27 = Utf8               ([Ljava/lang/String;)V
  #28 = Utf8               args
  #29 = Utf8               [Ljava/lang/String;
  #30 = Utf8               SourceFile
  #31 = Utf8               HelloExample.java
  #32 = NameAndType        #14:#15        // "<init>":()V
  #33 = NameAndType        #7:#8          // value:I
  #34 = Utf8               abc
  #35 = NameAndType        #9:#10         // s:Ljava/lang/String;
  #36 = Utf8               HelloExample
  #37 = Utf8               java/lang/Object

• 文本字符串 ，也就是我们经常声明的：public String s = "abc";中的"abc"

     #3 = String             #34            // abc
  

• 用final修饰的 成员变量，包括静态变量 、实例变量 和局部变量

    #11 = Utf8               f
    #12 = Utf8               ConstantValue
    #13 = Integer            257
  

• 类和接口 的全限定名 ，也就是Ljava/lang/String;这样，将类名中原来的"."替换为"/"得到的，主要用于在运行时解析得到类的直接引用.

     #5 = Class              #36            // HelloExample
     #6 = Class              #37            // java/lang/Object
  

• 字段 的名称 和描述符 ，字段也就是类或者接口中声明的变量 ，包括类级别变量(static)和 实例级的变量

     #2 = Fieldref           #5.#33         // HelloExample.value:I
     #7 = Utf8               value
     #8 = Utf8               I
  

• 通过一个类的“全限定名”来获取此类的 二进制字节流
• 将这个字节流所代表的静态储存结构 转化为方法区的运行时数据结构
• 在内存中生成一个类代表这类的java.lang.Class对象 ，作为方法区这个类的各种数据访问的入口

String str=new String("abc");

1. 首先，我们看到这个代码中有一个new关键字，我们知道new 指令是创建一个类的实例对象并完成加载初始化的，因此这个字符串对象是在运行期 才能确定的，创建的字符串对象是在堆内存上 。
2. 其次，在String的构造方法中传递了一个字符串abc，由于这里的abc是被final修饰的属性，所以它是一个字符串常量。在首次构建这个对象时，JVM拿字面量"abc"去字符串常量池试图获取其对应String对象的引用。于是在堆中创建了一个"abc"的String对象，并将其引用保存到字符串常量池中，然后返回；