JDK vs JRE vs JVM
Java is the backbone of countless enterprise systems, mobile apps, and embedded devices. Its platform independence and scalability are driven by three core components: the JDK, JRE, and JVM.
Understanding how these components interact is key to mastering Java development. In this chapter, we will break down each one - exploring their roles, how they work together, and why they are essential to the Java ecosystem.
Expect clear explanations, diagrams, and practical analogies to bridge concept with code.
What is JRE?
The Java Runtime Environment (JRE) provides the minimum set of resources required to run Java applications. It is essentially the runtime portion of Java- what you need to execute Java programs, but not to develop them.
The JRE includes:
- Java Virtual Machine (JVM) – the engine that interprets and executes Java bytecode
- Core Java class libraries – essential APIs like java.lang, java.util, etc.
- Supporting configuration files and runtime libraries
Unlike the JDK, the JRE does not include development tools such as the compiler (javac) or debugger. It is designed for end-users who want to run Java applications without needing to write or compile code.
In short, the JRE acts as the bridge between compiled Java bytecode and the underlying operating system, making Java's “write once, run anywhere” philosophy possible at runtime.
What is JVM?
The Java Virtual Machine (JVM) is the engine at the heart of Java’s platform independence. It is an abstract computing machine that enables a computer to run Java bytecode - compiled .class files produced by the Java compiler.
Key responsibilities of the JVM include:
- Loading class files
- Verifying bytecode for security
- Interpreting or compiling bytecode to native machine code (via JIT compilation)
- Managing memory via garbage collection
- Handling exceptions and thread management
What is JDK?
The Java Development Kit (JDK) is the core development environment for building Java applications and applets. It provides the necessary tools and libraries to write, compile, and run Java code. Unlike some components of the Java ecosystem, the JDK is a tangible software package—it physically exists and is installed on the developer's machine.
At its core, the JDK includes the Java Runtime Environment (JRE) along with a comprehensive suite of development tools, such as:
- javac – the Java compiler
- java – the launcher/interpreter for Java applications
- jar – the archiver for packaging Java classes
- javadoc – the tool for generating API documentation
- several debugging and monitoring utilities
The JDK is available in multiple platform variants released by Oracle Corporation:
- Java Standard Edition (SE) – for general-purpose applications
- Java Enterprise Edition (EE) – for large-scale, distributed, and web-based applications
- Java Micro Edition (ME) – for mobile and embedded systems
Each variant includes a private JVM tailored for its target environment, making the JDK the backbone of Java development across platforms.
How JDK, JRE, and JVM Work Together
To fully understand Java’s architecture, it’s important to see how the JDK, JRE, and JVM function as parts of a unified development and execution pipeline.
Here's how they interact:
-
You write Java code using the tools provided by the JDK—typically in
.javasource files. -
The JDK’s compiler (
javac) compiles this source code into bytecode (.classfiles), which is a platform-independent intermediate representation. -
To run the application, the JRE steps in. It provides the runtime environment—including all necessary class libraries and configuration files—to execute the bytecode.
-
The JVM, which is part of the JRE, loads and interprets (or JIT compiles) the bytecode into native machine code for the host operating system.
-
During execution, the JVM handles memory management, garbage collection, security checks, and thread management, ensuring safe and efficient program execution.
In summary:
-
The JDK is for developing Java applications.
-
The JRE is for running Java applications.
-
The JVM is the engine that executes the bytecode on the host machine.
Comparison Table
| Feature | JDK ( Java Development Kit ) | JRE ( Java Runtime Environment ) | JVM ( Java Virtual Machine ) |
|---|---|---|---|
Definition
|
Full toolkit for Java development; includes everything in JRE plus development tools
|
Environment to run Java applications; includes JVM and libraries
|
Abstract machine that executes Java bytecode
|
Primary Purpose
|
Develop, compile, debug, and run Java applications
|
Run Java applications
|
Execute Java bytecode
|
Includes
|
JRE, compiler (javac), debugger, JavaDoc, JShell, other dev tools
|
JVM, core libraries, supporting files
|
Only the runtime environment for executing bytecode
|
Development Tools
|
Yes (compiler, debugger, etc.)
|
No
|
No
|
Execution Tools
|
Yes (can both compile and run code)
|
Yes (can run code only)
|
Yes (executes bytecode)
|
Platform Dependency
|
Platform dependent (different JDK for Windows, Mac, Linux)
|
Platform dependent (different JRE for each OS)
|
Platform independent (specification; implementations are OS-specific)
|
Can Compile Code?
|
Yes
|
No
|
No
|
Can Run Code?
|
Yes
|
Yes
|
Yes (executes bytecode, but needs to be invoked via JRE/JDK)
|
Example Use Case
|
Building and testing a new Java application
|
Running a Java-based desktop application
|
Running any Java application on any OS
|
Fun Analogy
- JDK: The kitchen, with all the utensils and ingredients to cook a meal (write and build Java apps).
- JRE: The dining table, set and ready to serve the meal (run Java apps).
- JVM: The chef, who takes the recipe (bytecode) and cooks it perfectly, no matter the kitchen (platform)
Check your Java version
java -version
javac -version