What the JVM, JDK and JRE each do

Understanding What the JVM, JDK and JRE each do

The JVM is a specification of an abstract machine, and HotSpot, Eclipse OpenJ9 and others are implementations of it. It reads class files, a compact instruction set for a stack machine, and never sees your .java text, which is why Kotlin, Scala and Clojure compile to the same class files and run on the same engine. At run time it verifies incoming bytecode, places objects on a heap it garbage-collects, and starts by interpreting before a JIT compiler translates hot methods into instructions for whatever CPU it happens to be on. It also pins down semantics: int is 32-bit two's complement everywhere, double is IEEE 754, an out-of-range array index must throw, so the same class file produces the same values on a laptop and on a server.

Bytecode on its own cannot print anything. The first line most people write calls System.out.println, and that code is already compiled and shipped with the runtime, alongside String, ArrayList, the file and network APIs, and the native libraries behind them. A JRE is exactly that pairing, a JVM plus the standard class library: enough to run a program, with no compiler anywhere in it. OpenJDK stopped publishing a standalone JRE after Java 8, since Java 9 the library is split into modules and a right-sized runtime is assembled with jlink, so today "JRE" usually means a vendor's runtime-only package.

A JDK is a complete runtime plus the tools that create and inspect class files: javac, jar, javadoc, javap, jshell, jlink, jpackage, and diagnostics such as jcmd. That gives the nesting: anything a JRE can do a JDK can do too, which is why the practical advice is to install a JDK and stop thinking about the JRE at all. The one relationship that is not symmetric is version. A JVM loads class files up to its own class-file version, so a Java 21 JVM happily runs Java 8 class files, while a Java 11 JVM rejects everything javac 21 produced.

public class WhatEachPartDid {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;
        System.out.println(max);
        System.out.println(max + 1);       // 32-bit two's complement wrap, fixed by the JVM
        System.out.println((int) -3.9);    // narrowing truncates toward zero
        System.out.println(0.1 + 0.2);     // IEEE 754 double arithmetic
        System.out.println("String came from module " + String.class.getModule().getName());
    }
}

Worked examples

import javax.tools.ToolProvider;

public class WhichJava {
    public static void main(String[] args) {
        System.out.println("runtime version: " + Runtime.version());
        System.out.println("vm name:         " + System.getProperty("java.vm.name"));
        System.out.println("java.home:       " + System.getProperty("java.home"));
        System.out.println("compiler here:   " + (ToolProvider.getSystemJavaCompiler() != null));
    }
}

public class WhoChecks {
    public static void main(String[] args) {
        Object boxed = "text";
        try {
            Integer n = (Integer) boxed;
            System.out.println(n);
        } catch (ClassCastException e) {
            System.out.println("cast rejected at run time: " + e.getMessage());
        }

        int[] pair = new int[2];
        try {
            pair[5] = 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("index checked at run time: " + e.getMessage());
        }
    }
}

Important notes

Common mistakes

Try it yourself