JVM, JRE ਅਤੇ JDK ਵਿਚਕਾਰ ਕੀ ਅੰਤਰ ਹੈ?

Question

Accepted Answer

ਇਹ ਤਿੰਨ ਸੰਖੇਪ ਨਾਮ Java ਪਲੇਟਫਾਰਮ ਦੀਆਂ ਨੇਸਟਡ ਪਰਤਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ। ਯਾਦ ਰੱਖਣ ਦਾ ਸਭ ਤੋਂ ਸਰਲ ਤਰੀਕਾ: **JDK ਵਿੱਚ JRE ਸ਼ਾਮਲ ਹੈ, ਜਿਸ ਵਿੱਚ JVM ਸ਼ਾਮਲ ਹੈ** — ਹਰ ਇੱਕ ਇਸਦੇ ਅੰਦਰ ਵਾਲੀ ਪਰਤ ਵਿੱਚ ਸਮਰੱਥਾਵਾਂ ਜੋੜਦਾ ਹੈ।

## Nesting

```text
┌─────────────────────────── JDK (Development Kit) ───────────────────┐
│  javac (compiler), debugger, javadoc, jar, other dev tools          │
│  ┌─────────────────────── JRE (Runtime Environment) ─────────────┐  │
│  │  Java class libraries (standard API: java.util, java.io, ...)  │  │
│  │  ┌──────────────────── JVM (Virtual Machine) ───────────────┐  │  │
│  │  │  Executes bytecode, JIT compilation, garbage collection   │  │  │
│  │  └───────────────────────────────────────────────────────────┘  │  │
│  └─────────────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────────────┘
```

## JVM — Java Virtual Machine (runtime ਇੰਜਨ)

```text
Executes the bytecode. Responsibilities:
  ✓ Loads .class files, verifies bytecode
  ✓ Interprets / JIT-compiles bytecode to native machine code
  ✓ Manages memory & garbage collection
It's the layer that makes "write once, run anywhere" work — platform-specific
JVMs run the SAME bytecode.
```

## JRE — Java Runtime Environment (ਐਪ ਚਲਾਉਣ ਲਈ)

```text
JVM + the standard class libraries (the built-in API your code calls).
What you need to RUN a Java application — but NOT to compile one.
```

## JDK — Java Development Kit (ਐਪ ਬਣਾਉਣ ਲਈ)

```text
JRE + development tools:
  javac   — the compiler (.java → .class bytecode)
  jdb     — debugger
  javadoc — documentation generator
  jar     — packaging tool
What a DEVELOPER needs to write, compile, and build Java programs.
```

## ਤੁਹਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ?

```text
Writing/compiling Java code  → JDK (it includes everything)
Only running a Java app      → JRE was historically enough
  (modern Java often bundles the runtime; JRE is less separately distributed now)
```

## ਇਸ ਦਾ ਮਹੱਤਵ ਕਿਉਂ ਹੈ

JVM/JRE/JDK ਅਤੰਤਰ ਨੂੰ ਸਮਝਣਾ Java ਪਲੇਟਫਾਰਮ ਦੀ ਬਣਤਰ ਨੂੰ ਸਪਸ਼ਟ ਕਰਦਾ ਹੈ ਅਤੇ ਵਿਹਾਰਕ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦਿੰਦਾ ਹੈ: ਡਿਵੈਲਪਰ **JDK** ਇੰਸਟਾਲ ਕਰਦੇ ਹਨ (ਕੰਪਾਇਲ ਅਤੇ ਬਿਲਡ ਕਰਨ ਲਈ), **JVM** ਅਸਲ ਵਿੱਚ bytecode ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਪਲੇਟਫਾਰਮ ਸਮਚੋਂ ਅਲਹਿਦਾ + ਓਘਾੜੀ ਕਲੈਕਸ਼ਨ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ **JRE** ਐਤਿਹਾਸਿਕ ਤੌਰ 'ਤੇ ਸਿਰਫ ਐਪ ਚਲਾਉਣ ਲਈ runtime ਪ੍ਰਦਾਨ ਕਰਦਾ ਥਾ।

ਇਹ ਲੇਅਰਡ ਮਾਡਲ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ Java ਕੋਡ ਸਰੋਤ ਤੋਂ ਚਲਦੇ ਪ੍ਰੋਗ੍ਰਾਮ ਤੱਕ ਕਿਵੇਂ ਜਾਂਦਾ ਹੈ, WORA ਕਿਉਂ ਕੰਮ ਕਰਦਾ ਹੈ (JVM ਪਰਤ), ਅਤੇ ਦਿੱਤੇ ਗਏ ਕੰਮ ਲਈ ਕੀ ਇੰਸਟਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ — ਕਿਸੇ ਵੀ Java ਵਾਤਾਵਰਣ ਨੂੰ ਸੈਟਅਪ ਕਰਨ ਅਤੇ ਕਾਰਨ ਦੇਣ ਲਈ ਬੁਨਿਆਦੀ ਗਿਆਨ।