JDK, JRE, and JVM difference in Java - Deep Dive

Overview - JDK, JRE, and JVM difference

What is it?

JDK, JRE, and JVM are three important parts of Java technology. JVM (Java Virtual Machine) runs Java programs by turning code into actions on your computer. JRE (Java Runtime Environment) includes JVM and tools needed to run Java programs but not to create them. JDK (Java Development Kit) has everything in JRE plus tools to write and build Java programs.

Why it matters

Without these parts, Java programs wouldn't run or be created easily. JVM makes Java programs work on any computer, JRE lets you run them, and JDK lets you write them. Without understanding these, you might get confused about how Java works or why some programs don't run or compile.

Where it fits

Before this, you should know what Java programs are and basic programming ideas. After this, you can learn how to write, compile, and run Java code using tools like javac and java commands.

Mental Model

Core Idea

JVM runs Java code, JRE provides the environment to run it, and JDK includes tools to create and run Java programs.

Think of it like...

Think of JVM as the engine of a car that makes it move, JRE as the complete car ready to drive, and JDK as the car plus the tools to build or fix it.

┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│    JVM      │◄─────│    JRE      │◄─────│    JDK      │
│ (runs code) │      │(runs + libs)│      │(dev tools)  │
└─────────────┘      └─────────────┘      └─────────────┘

Build-Up - 6 Steps

1

Foundation

What is JVM and its role

Concept: Introduce JVM as the core part that runs Java programs.

JVM stands for Java Virtual Machine. It reads Java bytecode (a special code Java programs are turned into) and runs it on your computer. JVM makes Java programs work the same way on any device, no matter the hardware or operating system.

Result

Java programs can run anywhere because JVM handles the differences in computers.

Understanding JVM is key because it explains why Java is called 'write once, run anywhere.'

2

Foundation

Understanding JRE and its purpose

Concept: Explain JRE as the package that includes JVM and libraries to run Java programs.

JRE stands for Java Runtime Environment. It contains JVM plus the standard Java libraries and other files needed to run Java applications. If you only want to run Java programs, you install JRE on your computer.

Result

You can run Java programs but cannot create or compile new ones with just JRE.

Knowing JRE helps you understand what is needed to run Java apps without development tools.

3

Intermediate

Introducing JDK and its components

Concept: Show that JDK includes JRE plus tools to develop Java programs.

JDK stands for Java Development Kit. It has everything in JRE plus tools like the Java compiler (javac) and debugger. These tools let you write, compile, and debug Java programs. Developers install JDK to create Java software.

Result

With JDK, you can write new Java programs and run them on your computer.

Recognizing JDK as a superset of JRE clarifies why developers need it but users might not.

4

Intermediate

How JVM, JRE, and JDK work together

🤔Before reading on: Do you think JVM can run Java programs without JRE or JDK? Commit to your answer.

Concept: Explain the relationship and dependencies among JVM, JRE, and JDK.

JVM is inside JRE, and JRE is inside JDK. JVM runs the Java bytecode. JRE provides JVM plus libraries to support running programs. JDK adds tools to write and compile code. You cannot run Java programs without JVM, and you cannot develop Java programs without JDK.

Result

Clear understanding of how these parts fit and why each is needed for different tasks.

Knowing their hierarchy prevents confusion about what to install for running vs developing Java.

5

Advanced

Differences in JDK versions and distributions

🤔Before reading on: Do you think all JDKs are the same regardless of vendor or version? Commit to your answer.

Concept: Discuss how different JDK versions and vendors may vary in features and licensing.

There are many JDK distributions like Oracle JDK, OpenJDK, and others. They all provide JVM, JRE, and development tools but may differ in performance, support, and licensing. Newer JDK versions add features and improvements. Choosing the right JDK depends on your project needs and environment.

Result

You understand that not all JDKs are identical and why that matters for production use.

Recognizing JDK diversity helps avoid compatibility and legal issues in real projects.

6

Expert

JVM internals and runtime optimizations

🤔Before reading on: Do you think JVM just interprets bytecode without any optimization? Commit to your answer.

Concept: Reveal how JVM uses techniques like Just-In-Time compilation and garbage collection to run Java efficiently.

JVM does more than just read bytecode. It uses Just-In-Time (JIT) compilation to turn bytecode into fast machine code while running. It also manages memory automatically with garbage collection, freeing unused objects. These features make Java programs run faster and more reliably.

Result

You appreciate JVM as a complex engine that optimizes Java execution dynamically.

Understanding JVM internals explains why Java can be both portable and performant.

Under the Hood

JVM loads Java bytecode and either interprets it or compiles it into native machine code at runtime using JIT. It manages memory with a heap and stack, performing garbage collection to free unused objects. JRE bundles JVM with standard libraries and runtime files. JDK adds compilers and tools that translate Java source code into bytecode and help debug and package applications.

Why designed this way?

Java was designed for portability and security. JVM abstracts hardware differences, allowing the same bytecode to run anywhere. Separating runtime (JRE) from development tools (JDK) keeps environments lightweight for users and full-featured for developers. JIT and garbage collection improve performance and ease of programming, balancing speed and safety.

┌───────────────┐
│  Java Source  │
└──────┬────────┘
       │ javac compiler
       ▼
┌───────────────┐
│  Bytecode (.class) │
└──────┬────────┘
       │ loaded by JVM
       ▼
┌───────────────┐
│     JVM       │
│ ┌───────────┐ │
│ │Interpreter│ │
│ │  & JIT    │ │
│ └───────────┘ │
│ Garbage Coll. │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Native OS    │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Is JRE enough to develop Java programs? Commit to yes or no.

Common Belief: JRE is enough to write and compile Java programs.

Reality: JRE only lets you run Java programs; it does not include tools to write or compile code. You need JDK for development.

Why it matters: Trying to develop with only JRE leads to errors and confusion because compilers and debuggers are missing.

Quick: Does JVM run programs directly from Java source code? Commit to yes or no.

Common Belief: JVM runs Java source code directly without any conversion.

Reality: JVM runs bytecode, which is compiled from Java source code by the Java compiler in JDK.

Why it matters: Misunderstanding this can cause confusion about the compile and run steps in Java development.

Quick: Are all JDKs exactly the same regardless of vendor? Commit to yes or no.

Common Belief: All JDKs are identical and interchangeable.

Reality: Different JDK vendors may provide different features, performance, and licenses, affecting your project.

Why it matters: Choosing the wrong JDK can cause compatibility issues or legal problems in production.

Quick: Does JVM only interpret bytecode without optimization? Commit to yes or no.

Common Belief: JVM just interprets bytecode slowly without any performance improvements.

Reality: JVM uses Just-In-Time compilation to convert bytecode into fast machine code during runtime, improving performance.

Why it matters: Underestimating JVM's optimizations can lead to wrong assumptions about Java's speed and efficiency.

Expert Zone

1

JVM implementations can differ in garbage collection algorithms, affecting performance and memory usage subtly.

2

JDK includes tools like jlink to create custom runtime images, optimizing deployment size and startup time.

3

JRE is often bundled inside JDK but can be separated for lightweight runtime environments, important for containerized apps.

When NOT to use

Use JDK only when developing Java applications. For running Java programs on servers or user machines, use JRE to save space. For non-Java languages on JVM (like Kotlin or Scala), JDK is still needed for development but runtime may differ. Alternatives like GraalVM offer ahead-of-time compilation for special use cases.

Production Patterns

In production, developers use JDK to build and test applications, then deploy with JRE or custom runtime images. JVM tuning (like garbage collector settings) is common to optimize performance. Different JDK vendors are chosen based on support and licensing, especially in enterprise environments.

Connections

Operating System Abstraction

JVM acts as an abstraction layer between Java programs and the operating system.

Understanding JVM as an OS abstraction helps grasp how Java achieves portability across different hardware and OS platforms.

Compiler Design

JDK includes a compiler that translates Java source code into bytecode, similar to how other compilers translate code.

Knowing compiler design principles clarifies why Java uses bytecode as an intermediate step before execution.

Virtual Machines in Computer Science

JVM is a type of virtual machine that simulates a computer environment for Java bytecode.

Recognizing JVM as a virtual machine connects Java to broader concepts in computer science about abstraction and emulation.

Common Pitfalls

#1 Trying to run Java programs without installing JRE or JDK.

Wrong approach:

java MyProgram

Correct approach:

Install JRE or JDK first, then run: java MyProgram

Root cause:

Not understanding that JVM and runtime environment are needed to execute Java programs.

#2 Attempting to compile Java code with only JRE installed.

Wrong approach:

javac MyProgram.java (with only JRE installed)

Correct approach:

Install JDK, then run: javac MyProgram.java

Root cause:

Confusing JRE with JDK and expecting runtime tools to include development tools.

#3 Using an outdated JDK version that lacks needed features.

Wrong approach:

Using JDK 8 for a project requiring Java 17 features.

Correct approach:

Install and use JDK 17 or later for the project.

Root cause:

Not matching JDK version to project requirements and missing new language features.

Key Takeaways

JVM is the engine that runs Java bytecode, enabling Java's portability across devices.

JRE includes JVM and libraries needed to run Java programs but lacks development tools.

JDK contains JRE plus compilers and tools to write, compile, and debug Java applications.

Understanding the hierarchy and roles of JVM, JRE, and JDK helps avoid confusion in Java development and deployment.

JVM uses advanced techniques like Just-In-Time compilation and garbage collection to optimize Java program execution.