Table of Contents

1. Introduction
2. JVM (Java Virtual Machine)
   • Architecture of the JVM
     • Class Loader
     • JVM Memory
       • Method Area
       • Heap
       • Stack Area
       • Program Counter (PC) Register
       • Native Method Stack
     • Execution Engine
       • Interpreter
       • Just-In-Time (JIT) Compiler
       • Garbage Collector
3. JRE (Java Runtime Environment)
   • Key Components of the JRE
     • Execution Tasks
     • Class Libraries
     • Java Native Interface (JNI)
     • Security Manager
4. JDK (Java Development Kit)
   • Core Features of the JDK
     • javac (Java Compiler)
     • java (Java Application Launcher)
     • jdb (Java Debugger)
     • jar (Java Archive Tool)
     • javadoc (Java Documentation Generator)
5. JVM vs JRE vs JDK: What's the Difference?
6. JDK, JRE, JVM Hierarchy

Introduction

The Java ecosystem is the broad set of tools, technologies, libraries, and frameworks that surround and support the Java programming language. It encompasses everything needed to develop, deploy, and manage Java applications. It revolves around JDK, JRE, JVM

JVM (Java Development Kit)

The JVM acts like a translator that allows your computer to run Java programs and other languages compiled into Java bytecode. It translates the code into something your computer's hardware can understand and execute.

Architecture of the JVM

Class Loader

1. Loading load
   Load .class files into memory. Locates, loads, and links class files (Java bytecode) for execution.

2. Linking

   • Verification: Verifies the bytecode.
   • Preparation: Allocates memory for static variables and initializes the memory to default values.
   • Resolution: Resolves symbolic references to direct references.

3. Initialization
   Initialization is the final step where the JVM prepares a class or interface for use. This step happens after the class has been loaded (into memory) and linked.

JVM Memory

1. Method Area
   Method area Stores class-level data such as methods and variables, the runtime constant pool, and code for methods.
   

   public class Person {
       private String name;
   
       public void setName(String name) {
           this.name = name;
       }
   }
   

   When you define a class Person, the Method Area stores the structure of the Person class, including its methods (setName) and fields (name), and the runtime constant pool which contains references like method names and constant values.

2. Heap
   Heap is where the runtime memory objects are allocated. The heap is shared among all threads and is where the garbage collection process occurs.
   

   Person p = new Person();
   

   When you create a new Person object, it is allocated on the Heap.

3. Stack Area
   Stack area stores frames, which contain local variables, operand stacks, and references to the runtime constant pool of the class being executed. Each thread has its own stack.
   

   public void someMethod() {
       int a = 10;
       int b = 20;
       int sum = a   b;
   }
   

   Each time someMethod is called, a new frame is pushed onto the Stack Area. This frame includes local variables (a, b, and sum), an operand stack for intermediate calculations, and a reference to the method’s class in the Runtime Constant Pool.

4. Program Counter (PC) Register
   PC contains the address of the current JVM instruction being executed. Each thread has its own PC register.

5. Native Method Stack
   Similar to the Java stack, but used for native methods.

Execution Engine

1. Interpreter
   Interpreter reads Java bytecode and executes it line by line, converting each bytecode instruction into a sequence of machine-level instructions that can be executed by the CPU.

2. Just-In-Time (JIT) Compiler
   Converts bytecode into native machine code at runtime to improve performance.

3. Garbage Collector
   Garbage collector is responsible for automatically managing memory in the JVM. It identifies and deallocates memory that is no longer in use, freeing it up for new objects.

JRE

JRE is a software package that provides the necessary environment to run Java applications. It is designed to execute Java bytecode on a machine, making it an essential part of the "write once, run anywhere" (WORA) principle of Java.

Key Components of the JRE

1. Execution Tasks
   The JRE facilitates the execution of Java applications by providing the JVM and the necessary libraries and resources. JRE ensures that the JVM has everything it needs to perform these tasks on any platform. Think of the JRE as the complete package that includes the JVM, which does the heavy lifting, and other components that support the execution of Java applications.

2. Class Libraries
   JRE includes a set of standard Java class libraries, which provide reusable code for performing common tasks, like data structures, I/O, networking, concurrency, and more.

3. Java Native Interface (JNI)
   JNI allows Java applications to interact with native code written in languages like C or C . This feature is essential for integrating platform-specific features or using existing native libraries.

4. Security Manager
   The Security Manager enforces security policies for Java applications, restricting actions such as file access, network connections, and the execution of potentially unsafe code.

JDK (Java Development Kit)

JDK is a tools that enables developers to write, compile, debug, and run Java applications. It is a superset of JRE and includes additional tools for Java development.

Core Features of the JDK

• javac (Java Compiler)
  javac is use to for converting Java source code (.java files) into bytecode (.class files). This bytecode is then executed by the Java Virtual Machine (JVM).

• java (Java Application Launcher)
  java command launches a Java application. It loads the necessary class files, interprets the bytecode, and starts the application.

• jdb (Java Debugger)
  jdb is the command-line debugger for Java programs. It allows you to inspect and debug Java applications at runtime.

• jar (Java Archive Tool)
  jar tool packages multiple files into a single archive file, typically with a .jar extension. These JAR files are used to distribute Java applications and libraries.

• javadoc (Java Documentation Generator)
  javadoc generates HTML documentation from Java source code, using the special /** */ comments known as doc comments.

JVM vs JVE vs JDK, what's the difference?

JDK, JRE, JVM hierarchy

JDK (Java Development Kit)
│
├── JRE (Java Runtime Environment)
│   │
│   ├── JVM (Java Virtual Machine)
│   │   ├── Class Loader
│   │   ├── Bytecode Verifier
│   │   ├── Execution Engine
│   │   │   ├── Interpreter
│   │   │   ├── Just-In-Time (JIT) Compiler
│   │   │   └── Garbage Collector
│   │   └── Runtime Libraries (core libraries like java.lang, java.util, etc.)
│   │
│   └── Java APIs (Core libraries and additional libraries)
│
├── Development Tools (like javac, jdb, jar, javadoc, etc.)
└── Documentation (API docs, guides)