JDK, JRE, JVM

What is JDK?

The Java Development Kit (JDK) is a software development environment used for developing Java applications. It includes everything needed to develop, compile, debug, and run Java programs.

JDK Components

JDK
├── JRE (Java Runtime Environment)
│   ├── JVM (Java Virtual Machine)
│   ├── Java Core Libraries
│   └── Supporting Files
├── Compiler (javac)
├── Debugger (jdb)
├── JAR Tool
├── Javadoc
└── Other Development Tools

Key JDK Tools

1. javac - Java compiler that converts .java to .class files
2. java - Launches the JVM to run Java applications
3. jar - Creates and manages JAR (Java Archive) files
4. javadoc - Generates API documentation from source code
5. jdb - Java debugger for finding and fixing bugs
6. javap - Disassembles class files
7. jconsole - Monitoring and management console

JDK Versions

# Check your Java version
java -version
javac -version

# Example output:
# java version "17.0.2" 2022-01-18 LTS
# Java(TM) SE Runtime Environment (build 17.0.2+8-LTS-86)
# Java HotSpot(TM) 64-Bit Server VM (build 17.0.2+8-LTS-86, mixed mode, sharing)

Installing JDK

# On Windows (using Chocolatey)
choco install oraclejdk17

# On macOS (using Homebrew)
brew install openjdk@17

# On Ubuntu/Debian
sudo apt install openjdk-17-jdk

# Set JAVA_HOME (Windows)
set JAVA_HOME=C:\\Program Files\\Java\\jdk-17

# Set JAVA_HOME (Linux/Mac)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

JDK Directory Structure

jdk-17/
├── bin/          # Executables (javac, java, jar)
├── conf/         # Configuration files
├── include/      # C/C++ header files
├── jmods/        # Module system files
├── lib/          # Libraries and classes
└── legal/        # Legal notices

What is JRE?

The Java Runtime Environment (JRE) is a software package that provides everything needed to run Java applications. It's a subset of the JDK.

JRE Components

JRE
├── JVM (Java Virtual Machine)
│   ├── Class Loader
│   ├── Bytecode Verifier
│   ├── Execution Engine
│   └── Runtime Data Areas
├── Java Class Libraries
│   ├── java.lang
│   ├── java.util
│   ├── java.io
│   ├── java.net
│   └── java.sql
└── Supporting Files

Core Libraries

// java.lang - Basic classes
String, Integer, Double, Math, System, Object

// java.util - Collections and utilities
ArrayList, HashMap, HashSet, Collections, Arrays

// java.io - Input/Output
File, InputStream, OutputStream, BufferedReader

// java.net - Networking
URL, HttpURLConnection, Socket

// java.sql - Database access
Connection, Statement, ResultSet

JRE vs JDK

Feature	JRE	JDK
Purpose	Run Java apps	Develop Java apps
Includes JVM	Yes	Yes
Includes Compiler	No	Yes
Includes Debugger	No	Yes
File Size	Smaller	Larger
Use Case	End users	Developers

JRE Execution Flow

.class file → Class Loader → Bytecode Verifier → Execution Engine → Machine Code
     │                              │                      │
     │                              │                      └─ JIT Compiler
     │                              │                         Interpreter
     │                              └─ Security Check
     └─ Load bytecode

JRE Memory Areas

public class MemoryExample {
    // Stored in Method Area (shared)
    static String CONSTANT = "Hello";
    
    // Stored in Heap (shared)
    static int[] sharedArray = new int[100];
    
    public static void main(String[] args) {
        // Stored in Stack (thread-specific)
        int localVar = 42;
        String message = "World";
        
        // Object stored in Heap, reference in Stack
        MemoryExample obj = new MemoryExample();
    }
}

What is JVM?

The Java Virtual Machine (JVM) is the runtime engine that executes Java bytecode. It's the heart of Java's platform independence.

JVM Architecture

┌─────────────────────────────────────────────────────┐
│                      JVM                             │
├─────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────────────────────┐  │
│  │ Class Loader │  │      Runtime Data Areas      │  │
│  │   System     │  │  ┌────────────┐  ┌────────┐ │  │
│  │             │  │  │Method Area │  │  Heap  │ │  │
│  │  Bootstrap  │  │  │            │  │        │ │  │
│  │  Extension  │  │  │            │  │        │ │  │
│  │  Application│  │  └────────────┘  └────────┘ │  │
│  └─────────────┘  │  ┌────────────┐  ┌────────┐ │  │
│                   │  │Stack(PER   │  │ PC     │ │  │
│  ┌─────────────┐  │  │  THREAD)   │  │Registers│ │  │
│  │ Execution   │  │  └────────────┘  └────────┘ │  │
│  │   Engine    │  └─────────────────────────────┘  │
│  │             │                                    │
│  │ Interpreter │  ┌─────────────────────────────┐  │
│  │ JIT Compiler│  │    Native Interface         │  │
│  │ GC          │  │    (JNI - Java Native       │  │
│  └─────────────┘  │     Interface)              │  │
│                   └─────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

Memory Model

public class JVM {
    // Method Area: Stores class metadata, static variables, constants
    static int classVariable = 10;
    
    // Heap: Stores objects and arrays
    int[] array = new int[100];
    String name = new String("Amazon");
    
    public void method() {
        // Stack: Stores local variables and method calls
        int localVar = 42;  // Primitive on stack
        Object obj = new Object();  // Reference on stack, object on heap
        
        // PC Register: Stores address of current instruction
        // Each thread has its own PC register
    }
}

JIT Compilation

The JVM uses Just-In-Time (JIT) compilation for performance:

1. Interpreter: Translates bytecode line by line (slow)
2. JIT Compiler: Compiles hot methods to native code (fast)
3. Method Cache: Stores compiled native code for reuse

// HotSpot JVM optimization
public class JITExample {
    // This method will be JIT compiled if called frequently
    public int calculate(int n) {
        return n * n + n / 2;
    }
    
    // The JIT compiler recognizes patterns and optimizes
    public long sum(int[] arr) {
        long sum = 0;
        for (int num : arr) {
            sum += num;  // Loop optimization
        }
        return sum;
    }
}

Garbage Collection

public class GCExample {
    public static void main(String[] args) {
        // Object eligible for GC when no references exist
        
        Object obj = new Object();  // Created
        obj = null;  // Now eligible for GC
        
        // Force garbage collection (not guaranteed)
        System.gc();
        
        // Finalize method (deprecated in Java 9+)
        // Called before object is reclaimed
    }
}

JDK vs JRE vs JVM Relationship

┌─────────────────────────────────────────┐
│                 JDK                      │
│  ┌───────────────────────────────────┐  │
│  │               JRE                  │  │
│  │  ┌─────────────────────────────┐  │  │
│  │  │             JVM              │  │  │
│  │  │  (Execute bytecode)         │  │  │
│  │  └─────────────────────────────┘  │  │
│  │  + Core Libraries                  │  │
│  │  + Runtime Support                 │  │
│  └───────────────────────────────────┘  │
│  + Compiler (javac)                      │
│  + Debugger (jdb)                        │
│  + JAR, Javadoc tools                    │
└─────────────────────────────────────────┘

Development vs Runtime

// DEVELOPMENT TIME (need JDK)
// 1. Write source code
public class App {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

// 2. Compile with javac (JDK tool)
// javac App.java → creates App.class

// RUNTIME (need JRE or JDK)
// 3. Run with java command
// java App → JVM executes bytecode

Scenario Matrix

Scenario	JDK Needed	JRE Needed	JVM Needed
Write Java code	Yes	No	No
Compile Java code	Yes	No	No
Run Java application	No	Yes	Yes
Debug Java application	Yes	No	No
Create JAR files	Yes	No	No
Deploy to production	No	Yes	Yes

Common Misconceptions

Myth: You need JDK to run Java programs
Reality: You only need JRE (or JRE + JVM) to run compiled .class files

Myth: JVM is the same for all platforms
Reality: Each platform has its own JVM implementation (HotSpot, OpenJ9, GraalVM)

// Demonstrating JVM-specific behavior
public class JVMDemo {
    public static void main(String[] args) {
        // Get JVM information
        String vmName = System.getProperty("java.vm.name");
        String vmVersion = System.getProperty("java.vm.version");
        String os = System.getProperty("os.name");
        
        System.out.println("JVM: " + vmName);
        System.out.println("Version: " + vmVersion);
        System.out.println("OS: " + os);
        
        // Memory information
        Runtime runtime = Runtime.getRuntime();
        long maxMemory = runtime.maxMemory();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        
        System.out.printf("Max Memory: %d MB%n", maxMemory / 1024 / 1024);
        System.out.printf("Total Memory: %d MB%n", totalMemory / 1024 / 1024);
        System.out.printf("Free Memory: %d MB%n", freeMemory / 1024 / 1024);
    }
}

Distribution Options

• Oracle JDK: Commercial, paid for production use
• OpenJDK: Open-source, free
• Amazon Corretto: Amazon's OpenJDK distribution
• Azul Zulu: High-performance OpenJDK
• GraalVM: Multi-language VM with polyglot support