JDK vs JRE vs JVM — Complete Explanation

Overview — JDK, JRE, and JVM

One of the most frequently asked questions in every Java interview — and one of the most confused topics for beginners — is: "What is the difference between JDK, JRE, and JVM?" These three terms are at the heart of how Java works, and understanding them clearly will give you a solid foundation for everything else in Java.

In simple terms: JVM is the engine that runs your Java program. JRE is the environment that provides JVM + standard libraries to run it. JDK is the complete toolkit that includes JRE + developer tools to write, compile, and run Java programs. The relationship is: JDK ⊇ JRE ⊇ JVM.

Real-World Analogy — Kitchen, Restaurant & Chef

Before going deep into technical details, let us understand JDK, JRE, and JVM through a simple real-world analogy that makes these concepts unforgettable.

Key insight: A diner (end user) only needs the kitchen (JRE) to enjoy the food (run the app). Only the chef (developer) needs the full kitchen + chef tools (JDK) to create new dishes.

What is JVM — Java Virtual Machine?

The Java Virtual Machine (JVM) is an abstract computing machine — a software layer that acts as a virtual computer inside your real computer. It is the core reason Java is platform-independent. The JVM does not care whether the underlying hardware is Windows, Linux, or macOS — it provides a uniform execution environment for Java bytecode.

The JVM performs four primary responsibilities every time a Java program runs:

Important: The JVM itself is platform-specific — there is a different JVM implementation for Windows, Linux, and macOS. But the bytecode it executes is platform-neutral. This is the magic of WORA — the bytecode is universal, only the JVM varies.

public class JVMInfo {
    public static void main(String[] args) {
        // JVM and Java version info
        System.out.println("Java Version  : " + System.getProperty("java.version"));
        System.out.println("JVM Name      : " + System.getProperty("java.vm.name"));
        System.out.println("JVM Version   : " + System.getProperty("java.vm.version"));
        System.out.println("JVM Vendor    : " + System.getProperty("java.vm.vendor"));
        System.out.println("Java Home     : " + System.getProperty("java.home"));
        System.out.println("OS Name       : " + System.getProperty("os.name"));
        System.out.println("OS Arch       : " + System.getProperty("os.arch"));

        // Memory info
        Runtime rt = Runtime.getRuntime();
        System.out.println("Max Heap      : " + (rt.maxMemory()  / 1024 / 1024) + " MB");
        System.out.println("Total Heap    : " + (rt.totalMemory()/ 1024 / 1024) + " MB");
        System.out.println("Free Heap     : " + (rt.freeMemory() / 1024 / 1024) + " MB");
        System.out.println("CPU Cores     : " + rt.availableProcessors());
    }
}

JVM Architecture — Deep Dive

The JVM is not a single monolithic program — it is a carefully designed system of three interconnected subsystems. Understanding this architecture is crucial for writing performant Java code and for cracking advanced Java interviews.

Class Loader Subsystem — How Java Loads Classes

The Class Loader Subsystem is the first stage of JVM execution. When your Java program starts, the JVM does not load all classes at once — it uses lazy loading, loading classes only when they are first needed. The Class Loader performs three phases:

Three Types of Class Loaders — Delegation Hierarchy

Delegation Model: When a class needs to be loaded, the Application ClassLoader first delegates to the Extension ClassLoader, which delegates to the Bootstrap ClassLoader. Only if the parent cannot find the class does the child attempt to load it. This prevents malicious code from replacing core Java classes like java.lang.String.

public class ClassLoaderDemo {
    public static void main(String[] args) {

        // Bootstrap ClassLoader loads java.lang.String
        // Returns null because Bootstrap CL is native (C++)
        System.out.println("String ClassLoader    : " +
            String.class.getClassLoader());

        // Application ClassLoader loads user-defined classes
        System.out.println("This class ClassLoader : " +
            ClassLoaderDemo.class.getClassLoader());

        // Parent ClassLoader chain
        ClassLoader cl = ClassLoaderDemo.class.getClassLoader();
        System.out.println("Parent ClassLoader    : " + cl.getParent());
        System.out.println("Grandparent CLoader   : " + cl.getParent().getParent());
    }
}

Runtime Data Areas — JVM Memory Model

The JVM divides memory into five distinct Runtime Data Areas. Understanding which data lives where is essential for writing memory-efficient Java programs and diagnosing OutOfMemoryError and StackOverflowError issues.

Heap Memory — Young & Old Generation

public class MemoryDemo {

    // Instance variable — stored in HEAP (part of the object)
    int instanceVar = 100;

    public static void main(String[] args) {

        // Local primitive — stored in STACK
        int localVar = 50;

        // Object reference 'obj' — stored in STACK
        // Actual MemoryDemo object — stored in HEAP
        MemoryDemo obj = new MemoryDemo();

        // String literal — stored in String Pool (part of Heap)
        String name = "Java";

        // 'new' String — always creates a new object in Heap
        String name2 = new String("Java");

        System.out.println("localVar   : " + localVar);          // Stack
        System.out.println("instanceVar: " + obj.instanceVar);   // Heap
        System.out.println("name == name2: " + (name == name2)); // false (different objects)
        System.out.println("name.equals: " + name.equals(name2));// true (same content)
    }
}

Execution Engine — Interpreter vs JIT Compiler

The Execution Engine is the heart of the JVM — it is responsible for actually running your Java bytecode. It has two strategies for executing bytecode, and understanding both explains why Java's performance has improved dramatically over the years.

How JIT Works: The JVM starts by interpreting all bytecode. It counts how many times each method is called. When a method crosses the invocation threshold (default: 10,000 times), the JIT compiler compiles it to native machine code. Future calls execute the native code directly — bypassing the interpreter entirely. This is why Java applications get faster over time the longer they run.

public class JITDemo {
    public static void main(String[] args) {

        // First run — JVM interprets bytecode (slower)
        long start1 = System.nanoTime();
        long result1 = computeSum(1_000_000);
        long time1 = System.nanoTime() - start1;

        // Second run — JIT has compiled computeSum to native code (faster)
        long start2 = System.nanoTime();
        long result2 = computeSum(1_000_000);
        long time2 = System.nanoTime() - start2;

        System.out.println("Result 1 : " + result1);
        System.out.println("Time 1   : " + time1 / 1_000_000 + " ms (interpreted)");
        System.out.println("Result 2 : " + result2);
        System.out.println("Time 2   : " + time2 / 1_000_000 + " ms (JIT compiled)");
    }

    static long computeSum(int n) {
        long sum = 0;
        for (int i = 1; i <= n; i++) sum += i;
        return sum;
    }
}

Garbage Collector — Automatic Memory Management

Java's Garbage Collector (GC) is one of its most celebrated features. Unlike C and C++ where developers manually allocate and free memory (malloc/free), Java's GC automatically identifies and reclaims memory occupied by objects that are no longer reachable from any live thread. This prevents the two most common memory bugs: memory leaks (forgetting to free) and dangling pointers (freeing and then using).

How Garbage Collection Works — Mark & Sweep

• ▶

  Phase 1 — Mark: The GC starts from GC Roots (active thread stacks, static variables, JNI references) and marks every reachable object in the Heap by traversing all references.

• ▶

  Phase 2 — Sweep: All objects NOT marked as reachable are considered garbage. The GC reclaims their memory.

• ▶

  Phase 3 — Compact (optional): Some GC algorithms compact live objects together to eliminate fragmentation, making future allocations faster.

public class GCDemo {
    String name;

    GCDemo(String name) {
        this.name = name;
        System.out.println("Created: " + name);
    }

    @Override
    protected void finalize() {
        // Called by GC before reclaiming memory (deprecated in Java 9+)
        System.out.println("GC collected: " + name);
    }

    public static void main(String[] args) throws Exception {
        GCDemo obj1 = new GCDemo("Object-A");  // obj1 → Heap
        GCDemo obj2 = new GCDemo("Object-B");  // obj2 → Heap

        obj1 = null;  // Object-A is now unreachable → eligible for GC
        obj2 = null;  // Object-B is now unreachable → eligible for GC

        System.gc();  // Request GC (JVM may or may not run it immediately)
        Thread.sleep(1000);
        System.out.println("Main method ends.");
    }
}

What is JRE — Java Runtime Environment?

The Java Runtime Environment (JRE) is the minimum software package required to run a pre-compiled Java application. It is a superset of the JVM — meaning it contains the JVM plus the standard Java class libraries that Java programs depend on.

Who needs JRE? End users who want to run a Java application (like a JAR file) but do not intend to develop Java programs. However, since Java 9 the standalone JRE is no longer distributed — you install the JDK instead, or create a custom minimal runtime using jlink.

What is JDK — Java Development Kit?

The Java Development Kit (JDK) is the complete toolkit for Java development. It is a superset of the JRE — it contains everything in the JRE plus a set of command-line developer tools. If you are a Java developer, you always install the JDK. As of Java 9, Oracle no longer ships a separate JRE — only the JDK.

The JDK is available from multiple vendors, all based on the same OpenJDK source code:

• ▶

  Eclipse Temurin (Adoptium): Most popular free OpenJDK build. Recommended for most developers.

• ▶

  Oracle JDK 21: Free under NFTC license. Same codebase as OpenJDK with Oracle-specific monitoring tools.

• ▶

  Amazon Corretto: Free OpenJDK with long-term AWS support. Best for AWS deployments.

• ▶

  Microsoft OpenJDK: Free, optimized for Azure and Windows environments.

• ▶

  GraalVM CE: Free OpenJDK + native image compilation + polyglot runtime.

JDK Developer Tools — Complete Reference

The JDK includes a rich set of command-line tools in its bin/ directory. Every Java developer should know these tools — especially javac, java, javap, jdb, and jar.

javap — Inspect Bytecode Like a Pro

# Compile the class first:
javac HelloWorld.java

# View method signatures (no bytecode):
javap HelloWorld

# View full bytecode disassembly:
javap -c HelloWorld

# View detailed bytecode + constant pool:
javap -verbose HelloWorld

JDK ⊇ JRE ⊇ JVM — Architecture Diagram

The diagram below shows the nested relationship between JDK, JRE, and JVM — from the outermost developer toolkit down to the innermost execution engine.

JDK vs JRE vs JVM — Master Comparison Table

This is the definitive comparison table for JDK, JRE, and JVM — covering every angle that can be asked in interviews.

End-to-End Bytecode Execution Flow

Let us trace the complete journey of a Java program — from the moment you type source code to the moment output appears on screen. Every step maps to a specific JVM component.

Heap vs Stack Memory — Key Differences

Understanding the difference between Heap and Stack memory is critical for Java performance tuning, debugging OutOfMemoryError, and interview success.

public class MemoryErrors {

    // Causes StackOverflowError — infinite recursion fills the Stack
    static void infiniteRecursion() {
        infiniteRecursion();  // calls itself forever
    }

    // Causes OutOfMemoryError — filling the Heap with objects
    static void fillHeap() {
        java.util.List<byte[]> list = new java.util.ArrayList<>();
        while (true) {
            list.add(new byte[1024 * 1024]);  // add 1MB chunks
        }
    }

    public static void main(String[] args) {
        try {
            infiniteRecursion();
        } catch (StackOverflowError e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
        }

        try {
            fillHeap();
        } catch (OutOfMemoryError e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
        }
    }
}

JDK vs JRE vs JVM — Interview Questions

These are the most commonly asked interview questions on JDK, JRE, JVM, and Java memory model — from fresher to mid-level positions.

Practice Questions — Test Your Knowledge

Test your understanding of JDK, JRE, and JVM concepts. Try answering each question before revealing the answer.

Conclusion — JDK vs JRE vs JVM Summary

You now have a thorough understanding of the three pillars of the Java platform. Let us consolidate everything with a final cheat-sheet summary:

With this understanding of Java's internals, you are now ready to move forward with confidence. The next chapter covers Java Syntax — variables, operators, control flow, and the rules that govern every line of Java code you write. ☕

Frequently Asked Questions (FAQ) — JDK vs JRE vs JVM