Maharaja Agrasen Institute of Technology

CIC-212
Java Programming

Lecture 3

Difference b/w JDK, JRE, JIT,

JVM, Class File Format
 Difference between JDK/JRE/JVM/JIT
JVM: Java Virtual Machine (JVM) is an
abstract computing machine. Java
programs are written against the JVM
specification. JVM is specific for OS
platform and they translate the Java
instructions to the underlying platform
specific instructions and execute them.
JVM enables the Java programs to be
platform independent.

JRE: Java Runtime Environment (JRE)

is an implementation of the JVM and
Java API.

JDK: Java Development Kit (JDK)

contains JRE along with various
development tools like Java libraries,
Java source compilers, Java debuggers,
bundling and deployment tools.

2
 Difference between JDK/JRE/JVM/JIT
JVM becomes an instance of JRE
at runtime of a java program. It is
widely known as a runtime
interpreter. The Java virtual
machine (JVM) is the cornerstone
on top of which the Java
technology is built upon. It is the
component of the Java technology
responsible for its hardware and
platform independence. JVM
largely helps in the abstraction of
inner implementation from the
programmers who make use of
libraries for their programmes from
JDK.

3
 Difference between JDK/JRE/JVM/JIT
JVM Internals
Like a real computing machine, JVM has an
instruction set and manipulates various memory
areas at run time. Thus for different hardware
platforms one has corresponding implementation
of JVM available as vendor supplied JREs. It is
common to implement a programming language
using a virtual machine.

A Java virtual machine instruction consists of an

opcode specifying the operation to be
performed, followed by zero or more operands
embodying values to be operated upon. From
the point of view of a compiler, the Java Virtual
Machine (JVM)is just another processor with an
instruction set, Java bytecode, for which code
can be generated. Life cycle is as follows,
source code to byte code to be interpreted by
the JRE and gets converted to the platform
specific executable ones.

4
 Difference between JDK/JRE/JVM/JIT

Just-in-time Compiler (JIT)

JIT is the part of the Java Virtual

Machine (JVM) that is used to speed
up the execution time. JIT compiles
parts of the byte code that have similar
functionality at the same time, and
hence reduces the amount of time
needed for compilation. Here the term
“compiler” refers to a translator from
the instruction set of a Java virtual
machine (JVM) to the instruction set of
a specific CPU.

5
 Java .class File Structure
We saw some basic of internals of JVM and
how it is divided into different components
that helps in execution of Java byte code.

Java Byte code as we saw is packed in a file

called class file (with .class extension). In this
ppt we will discuss the internals of a class file.
How the data is being written in a class file
and the class file format.

Let us see first the Diagrammatic

representation of a Java Class file.
 Java .class File Structure
A Java class file is consist of 10 basic sections:
1. Magic Number: 0xCAFEBABE
2. Version of Class File Format: the minor and
major versions of the class file
3. Constant Pool: Pool of constants for the class
4. Access Flags: for example whether the class is
abstract, static, etc.
5. this Class: The name of the current class
6. super Class: The name of the super class
7. interfaces: Any interfaces in the class
8. Fields: Any fields in the class
9. Methods: Any methods in the class
10. Attributes: Any attributes of the class (for
example the name of the sourcefile, etc.)

To Remember:
My Very Cute Animal Turns Savage In Full Moon Areas.
 Java .class File Structure
• The length of the Java class is not known before
it gets loaded. There are variable length sections
such as constant pool, methods, attributes etc.
These sections are organized in such a way that
they are prefaced by their size or length. This way
JVM knows the size of variable length sections
before actually loading them.

• The data written in a Class file is kept at one byte

aligned and is tightly packed. This helps in
making class file compact.

• The order of different sections in a Java Class file

is strictly defined so that the JVM knows what to
expect in a Class file and in which order it is
loading different components.
 Java .class File Structure

1. Magic number is used to uniquely identify the

format and to distinguish it from other formats.
The first four bytes of the Class file
are 0xCAFEBABE.
 Java .class File Structure
2. Version of Class file
The next four bytes of the class file contains major
and minor version numbers. This number allows the
JVM to verify and identify the class file. If the
number is greater than what JVM can load, the class
file will be rejected with the
error java.lang.UnsupportedClassVersionError.
You can find class version of any Java class file
using javap command line utility. For example:
javap -verbose MyClass

Consider we have a sample Java class:

public class Main {
public static void main(String [] args) {
int my_integer = 0xFEEDED;
}
}
 Java .class File Structure
2. Version of Class file
We compile this class using javac
Main.java command and create class file. Now
execute following command to see the major and
minor version of class file.

C:\>javap -verbose Main

Compiled from "Main.java"
public class Main extends
java.lang.Object
SourceFile: "Main.java"
minor version: 0
major version: 50
...
 Java .class File Structure
List of Major versions and corresponding JDK version of class
file

Major Version Hex JDK version

51 0x33 J2SE 7.0

50 0x32 J2SE 6.0
49 0x31 J2SE 5.0
48 0x30 JDK 1.4
47 0x2F JDK 1.3
46 0x2E JDK 1.2
45 0x2D JDK 1.1
 Java .class File Structure
3. Constant Pool
All the constants related to the Class or an Interface
will get stored in the Constant Pool. The constants
includes class names, variable names, interface
names, method names and signature, final variable
values, string literals etc.

The constants are stored as a variable length array element in the Constant
pool. The arrays of constants are preceded by its array size, hence JVM knows
how many constants it will expect while loading the class file. In above
diagram, the portion represented in green contains the size of the array.
 Java .class File Structure
3. Constant Pool
Within each array elements first byte represents a tag
specifying the type of constant at that position in the
array.
In below diagram the portion in orange represent the
one-byte tag. JVM identifies the type of the constant
by reading one-byte tag. Hence if one-byte tag
represents a String literal then JVM knows that next
2 bytes represents length of the String literal and rest
of the entry is string literal itself.

Java descriptor

Boolean Z

integer I

Object Ljava/lang/Object;

String[] Ljava/lang/String;

int foo(int,Object)
(ILjava/lang/Object;)I
 Java .class File Structure
3. Constant Pool
We can analyse the Constant Pool of any class file using javap command. Executing
javap on above Main class, we get following symbol table.

C:\>javap -verbose Main

Compiled from "Main.java"
public class Main extends java.lang.Object const #7 = Asciz Code;
SourceFile: "Main.java"
const #8 = Asciz LineNumberTable;
minor version: 0
major version: 50 const #9 = Asciz main;
Constant pool:
const #10 = Asciz ([Ljava/lang/String;)V;
const #1 = Method #4.#13; //
const #11 = Asciz SourceFile;
java/lang/Object."<init>":()V
const #12 = Asciz Main.java;
const #2 = int 16707053;
const #13 = NameAndType #5:#6;// "<init>":()V
const #3 = class #14; // Main
const #14 = Asciz Main;
const #4 = class #15; // java/lang/Object
const #15 = Asciz java/lang/Object;
const #5 = Asciz <init>;
const #6 = Asciz ()V;
 Java .class File Structure
3. Constant Pool
The constant pool has 15 entries in total. Entry #1 is Method public static void main;
#2 is for integer value 0xFEEDED (decimal 16707053). Also we have two entries
#3 and #4 which corresponds to this class and super class. Rest is the symbol table
storing string literals.

C:\>javap -verbose Main

Compiled from "Main.java"
public class Main extends java.lang.Object const #7 = Asciz Code;
SourceFile: "Main.java"
minor version: 0 const #8 = Asciz LineNumberTable;
major version: 50 const #9 = Asciz main;
Constant pool:
const #10 = Asciz ([Ljava/lang/String;)V;
const #1 = Method #4.#13; //
const #11 = Asciz SourceFile;
java/lang/Object."<init>":()V
const #12 = Asciz Main.java;
const #2 = int 16707053;
const #13 = NameAndType #5:#6;// "<init>":()V
const #3 = class #14; // Main
const #14 = Asciz Main;
const #4 = class #15; // java/lang/Object
const #15 = Asciz java/lang/Object;
const #5 = Asciz <init>;
const #6 = Asciz ()V;
 Java .class File Structure
4. Access flags
Access flags follows the Constant Pool. It is a two
byte entry that indicates whether the file defines a
class or an interface, whether it is public or abstract
or final in case it is a class. Below is a list of some of
the access flags and their interpretation.

Flag Name Value Interpretation

Declared public; may be accessed from

ACC_PUBLIC 0x0001
outside its package.

ACC_FINAL 0x0010 Declared final; no subclasses allowed.

Treat superclass methods specially when

ACC_SUPER 0x0020
invoked by the invokespecial instruction.

ACC_INTERFACE 0x0200 Is an interface, not a class.

ACC_ABSTRACT 0x0400 Declared abstract; may not be instantiated.

 Java .class File Structure
5. this class
This Class is a two byte entry that points to an index
in Constant Pool. In the diagram, this class has a
value 0x0007 which is an index in Constant Pool.
The corresponding entry
that is pointed by this
class Constant_pool
[this_class] in Constant
pool has two parts, first
part is the one-byte tag
that represents the type of
entry in constant pool, in
this case it is Class or
Interface. In the diagram
this is shown
in orange color.
And second entry is two-byte having index again in Constant pool. This above
diagram, two byte contain value 0x0004. Thus it points to Constant_pool [0x0004]
which is the String literal having name of the interface or class.
 Java .class File Structure
6. super Class
Next 2 bytes after this Class is of Super Class.
Similar to this class, value of two bytes is a pointer
that points to Constant pool which has entry for
super class of the class.

7. Interfaces
All the interfaces that are implemented by the class
(or interface) defined in the file goes in Interface
section of a class file. Starting two byte of the
Interface section is the count that provides
information about total number of interfaces being
implemented. Immediately following is an array that
contains one index into the constant pool for each
interface implemented by class.
 Java .class File Structure
8. Fields
A field is an instance or a class level variable
(property) of the class or interface. Fields section
contains only those fields that are defined by the
class or an interface of the file and not those fields
which are inherited from the super class or super
interface.
First two bytes in Fields section represents count:
that is the total number of fields in Fields Section.
Following the count is an array of variable length
structure one for each field. Each element in this
array represent one field. Some information is stored
in this structure where as some information like
name of the fields are stored in Constant pool.
 Java .class File Structure
9. Methods
The Methods component host the methods that are
explicitly defined by this class, not any other
methods that may be inherited from super class.
First two byte is the count of the number of methods
in the class or interface. The rest is again a variable
length array which holds each method structure.
Method structure contains several pieces of
information about the method like method argument
list, its return type, the number of stack words
required for the method’s local variables, stack
words required for method’s operand stack, a table
for exceptions, byte code sequence etc.
 Java .class File Structure
10. Attributes
Attribute section contains several attribute about the
class file, e.g. one of the attribute is the source code
attribute which reveals the name of the source file
from which this class file was compiled.
First two bytes in Attribute section is count of the
number of attributes, followed by the attributes
themselves. The JVMs will ignore any attributes they
don’t understand.