Quelle est la différence entre JVM, JRE et JDK ?

Question

Accepted Answer

Ces trois acronymes décrivent des couches imbriquées de la plateforme Java. Le moyen le plus simple de s'en souvenir : **JDK contient JRE, qui contient JVM** — chacun ajoute des capacités à celui qu'il enveloppe.

## Le modèle imbriqué

```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 (le moteur d'exécution)

```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 (pour EXÉCUTER les applications)

```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 (pour CONSTRUIRE les applications)

```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.
```

## De quoi avez-vous besoin ?

```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)
```

## Pourquoi c'est important

Comprendre la distinction JVM/JRE/JDK clarifie l'architecture de la plateforme Java et répond à des questions pratiques : les développeurs installent le **JDK** (pour compiler et construire), la **JVM** est ce qui exécute réellement le bytecode et permet l'indépendance de la plateforme + le garbage collection, et le **JRE** fournissait historiquement juste le runtime pour exécuter les applications.

Ce modèle en couches explique comment le code Java passe de la source au programme en exécution, pourquoi WORA fonctionne (la couche JVM), et ce qu'il faut installer pour une tâche donnée — une connaissance fondamentale pour configurer et raisonner sur n'importe quel environnement Java.