Mapping of Constant pool and method Area

Question

I am trying to understand how the class file is loaded into method area and execute. I am very much confused about the constant pool.

1. when the constant pool is created initially? while compiling the class file or when the class is loaded.

2. How the byte code is organized in method area What the method table consists of?

3. Can anyone show the sketch the picture representation of mapping in method area for clear understanding

Answer 1

Since the literal meaning of “constant pool” is just “pool of constants”, there are different things of the name, which are easy to confuse

1. Each class file has a constant pool describing all constants used in that class, which includes constant values but also symbolic references needed for linkage. Some entries fulfill both roles, e.g. class entries may serve as owner declaration for a symbolic reference to a member, needed when accessing a field or invoking a method, but may also be used to get a Class instance, e.g. for a class literal appearing in source code. Since it’s part of the class file, its format is specified within The Java® Virtual Machine Specification, §4 The class File Format, in §4.4. The Constant Pool.
   As said by other answers, you can use the command javap -v class.name to inspect the constant pool of a class.

2. There is a corresponding data structure at runtime, also known as run-time constant pool. Since certain values are represented as runtime objects (e.g. of type String, Class, MethodType, or MethodHandle), and symbolic references must be resolved to the runtime representation of the denoted classes and members, this structure is not the same as the byte sequence found in the class file. But these entries correspond, so that each time, an object is instantiated for a constant or a symbolic reference is resolved, the result can be remembered and reused the next time the same constant entry is accessed.

   This doesn’t imply that an implementation must have a 1:1 representation of each class’ constant pool. It’s possible that a specific implementation maps a class’ pool to a shared pool used for a all classes of the same class loading context, where each symbolic reference resolves to the same target.

3. There’s also the string pool, which can be seen as part of the runtime constant pool, holding references to all String instances associated with string constants, to allow resolving all identical string constants of all classes to the same String instance.

Answer 2

1. javac creates a constant pool when you compile your source to .class file. You can see it if you make

javap -v MyClass

to your MyClass.class

2. The Java Virtual Machine has a method area that is shared among all Java Virtual Machine threads. You can see bytecode of your class file by

'javap -c -v Main'

3. Method Area is just a part of the heap where JVM has all information about this class.

Answer 3

When a Java file is compiled, all references to variables and methods are stored in the class's constant pool as a symbolic reference.

Here is a link for your reference : What is the purpose of the Java Constant Pool?