JDK : versions, distributions et erreurs de version

Publié le · Mis à jour le

L'idée en une phrase

Le JDK (Java Development Kit) est la boîte à outils qui permet de compiler et exécuter du Java. Savoir quelle version est installée, laquelle ton projet attend et laquelle tourne en production évite une bonne partie des erreurs « ça marche chez moi ».

Une image pour comprendre : le moteur, la voiture et l'atelier

Trois sigles reviennent sans cesse : JVM, JRE, JDK. Ils s'emboîtent comme ceci :

  • la JVM (Java Virtual Machine), c'est le moteur : elle exécute le programme ;
  • le JRE (Java Runtime Environment), c'est la voiture prête à rouler : le moteur, plus les bibliothèques standard de Java ;
  • le JDK, c'est l'atelier complet : la voiture, plus tous les outils pour en construire une (le compilateur, entre autres).
JDK  ── outils de développement (javac, jar, jshell…)
 └── JRE  ── bibliothèques standard (String, List, LocalDate…)
      └── JVM  ── exécute le programme
Contient Pour qui ?
JDK tout : compiler + exécuter toi, le développeur, et le serveur d'intégration continue
JRE seulement exécuter un serveur de production qui fait juste tourner l'application
JVM le moteur d'exécution elle est toujours incluse, on ne l'installe jamais seule

Sur ton poste, tu installes un JDK. Le JRE seul ne permet pas de compiler.

Ce qu'il y a dans un JDK

Tu n'utiliseras presque jamais ces outils directement : Maven, Gradle et ton IDE les appellent pour toi. Mais il est utile de savoir qu'ils existent :

Outil Rôle
javac le compilateur : transforme tes fichiers .java en fichiers .class (du bytecode)
java lance un programme : démarre la JVM, qui exécute le bytecode
jar crée des archives .jar
jshell une console pour tester du Java ligne par ligne, sans créer de projet

Astuce : jshell est pratique pour tester rapidement une expression, par exemple un formatage de date ou une regex. Tape jshell dans un terminal, puis "Bonjour".toUpperCase().

Les versions de Java

Une nouvelle version tous les six mois

Une nouvelle version de Java sort en mars et en septembre, chaque année. Mais elles n'ont pas toutes le même statut :

  • les versions LTS (Long-Term Support) sont maintenues pendant des années : corrections de bugs et de failles de sécurité ;
  • les autres versions ne sont maintenues que six mois, jusqu'à la sortie de la suivante.

Les LTS sortent tous les deux ans :

Version Sortie Statut
Java 8 2014 LTS, encore présente dans de vieux projets
Java 11 2018 LTS
Java 17 2021 LTS, minimum pour Spring Boot 3 et 4
Java 21 2023 LTS, virtual threads
Java 25 2025 dernière LTS
Java 26, 27 2026 non LTS

Note : état en novembre 2026. La prochaine LTS est attendue en septembre 2027.

En entreprise, on utilise une version LTS. Les versions intermédiaires servent à découvrir les nouveautés, pas à faire tourner un projet : six mois après, elles ne reçoivent plus de correctifs de sécurité.

Le troisième chiffre compte aussi

Une version complète ressemble à 21.0.11. Le premier chiffre est la version de Java ; les suivants sont des mises à jour de cette version. Elles sortent tous les trimestres (janvier, avril, juillet, octobre) et corrigent surtout des failles de sécurité.

Rester en Java 21, c'est bien. Rester sur un 21.0.1 vieux de deux ans, beaucoup moins.

Les distributions : Oracle, Temurin, Corretto…

Java est un projet open source, OpenJDK. Plusieurs organisations le compilent et le distribuent. Le contenu est pratiquement identique ; ce qui change, c'est qui fournit les mises à jour et sous quelle licence.

Distribution Fournie par À retenir
Eclipse Temurin la fondation Eclipse (Adoptium) gratuite, très répandue : un bon choix par défaut
Amazon Corretto Amazon gratuite, courante sur AWS
Oracle JDK Oracle conditions de licence qui ont souvent changé : à vérifier avant usage en entreprise
Microsoft, Azul Zulu, BellSoft Liberica… divers gratuites, équivalentes pour un usage courant

Dans une équipe, la distribution est généralement déjà choisie. Utilise la même que tes collègues et que la production.

Installer et gérer plusieurs JDK

Tu auras souvent plusieurs projets, avec des versions de Java différentes. Pas besoin de désinstaller et réinstaller à chaque fois.

Avec IntelliJ IDEA : File → Project Structure → Project → SDK → Download JDK. Tu choisis la version et la distribution, IntelliJ l'installe et l'associe au projet. C'est la méthode la plus simple.

En ligne de commande (Linux, macOS, WSL) : l'outil SDKMAN! installe plusieurs JDK et passe de l'un à l'autre :

sdk list java              # les versions disponibles
sdk install java 25.0.1-tem  # installe une version (le nom exact vient de la liste)
sdk use java 21.0.11-tem     # utilise une autre version dans ce terminal

Astuce : télécharge toujours un JDK depuis le site officiel de la distribution (adoptium.net pour Temurin) ou via ces outils, jamais depuis un site de téléchargement quelconque.

Vérifier quelle version est utilisée

C'est le réflexe à avoir dès qu'une erreur de version apparaît :

java -version     # la version qui EXÉCUTE les programmes dans ce terminal
javac -version    # la version qui COMPILE
mvn -v            # la version que MAVEN utilise réellement (ligne "Java version")
echo $JAVA_HOME   # le JDK désigné par la variable JAVA_HOME

Ces quatre réponses peuvent être différentes ! Maven utilise le JDK désigné par JAVA_HOME, qui n'est pas forcément celui que lance la commande java. Et IntelliJ utilise le JDK configuré dans le projet, indépendamment des deux.

La version de Java dans le projet

Le projet indique pour quelle version de Java il est écrit. Avec Spring Boot et Maven, c'est une seule ligne dans le pom.xml :

<properties>
    <java.version>21</java.version>
</properties>

Avec Gradle :

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

Cette version doit être la même partout : sur ton poste, dans l'intégration continue et en production.

Les deux erreurs de version classiques

« release version 25 not supported »

[ERROR] Fatal error compiling: error: release version 25 not supported

Le projet demande Java 25, mais le JDK qui compile est plus ancien. Un JDK ne sait pas compiler pour une version qui n'existait pas encore quand il est sorti.

Solution : vérifie mvn -v et JAVA_HOME, et pointe vers un JDK 25 ou plus récent.

UnsupportedClassVersionError

java.lang.UnsupportedClassVersionError: fr/exemple/Application has been compiled by a more
recent version of the Java Runtime (class file version 69.0), this version of the Java Runtime
only recognizes class file versions up to 65.0

Le code a été compilé avec un JDK plus récent que celui qui l'exécute. Typiquement : compilé en Java 25 sur ton poste, lancé sur un serveur en Java 21.

Le message donne des numéros internes, faciles à traduire :

Numéro dans le message Version de Java
52 Java 8
55 Java 11
61 Java 17
65 Java 21
69 Java 25

Dans l'exemple : compilé en Java 25 (69), exécuté en Java 21 (65).

Règle à retenir : une JVM peut exécuter du code compilé pour sa version ou une version plus ancienne, jamais pour une version plus récente.

En production, avec Docker

Quand l'application est déployée dans un conteneur, la version de Java est choisie par l'image de base, dans le Dockerfile :

FROM eclipse-temurin:21-jre
COPY target/application.jar /app/application.jar
ENTRYPOINT ["java", "-jar", "/app/application.jar"]
  • 21 : la version de Java, qui doit correspondre au pom.xml ;
  • jre : en production, on exécute seulement, pas besoin du compilateur. L'image est plus légère et contient moins d'outils exploitables en cas d'attaque.

Quand l'équipe passe le projet à une nouvelle version de Java, il faut changer les deux : le pom.xml et le Dockerfile.

Les bonnes habitudes

  1. Utilise une version LTS pour tout projet, et la même que le reste de l'équipe.
  2. La même version partout : poste, intégration continue, production.
  3. Garde ton JDK à jour dans sa version : les mises à jour trimestrielles corrigent des failles.
  4. Face à une erreur de version, vérifie d'abord java -version, mvn -v et le JDK du projet dans l'IDE.
  5. Installe tes JDK via IntelliJ, SDKMAN! ou le site officiel de la distribution.
  6. Ne mets pas une version non LTS en production : elle ne reçoit plus de correctifs au bout de six mois.

À retenir

  • JVM = exécute, JRE = JVM + bibliothèques, JDK = JRE + outils de développement. Sur ton poste, il te faut un JDK.
  • Une version de Java sort tous les six mois ; on utilise les LTS (17, 21, 25). Spring Boot 3 et 4 demandent au minimum Java 17.
  • Temurin, Corretto, Oracle… sont des distributions du même OpenJDK.
  • java -version, mvn -v et l'IDE peuvent utiliser des JDK différents : vérifie-les en cas d'erreur.
  • Une JVM exécute du code compilé pour sa version ou une plus ancienne, jamais une plus récente.

Avis sur l'article

Pas encore de note : soyez le premier à donner votre avis.

Les avis sont publiés après validation par le modérateur.

Votre note