Apprendre Java moderne avec un IDE libre — du débutant au professionnel
Juin 2026 · JDK 25 LTS · Eclipse IDE 2026-06 (4.40)
Contrairement à des langages stabilisés, Java est un langage très vivant : une nouvelle
version tous les six mois (mars / septembre) et une LTS tous les deux ans (Java 17, 21, 25,
puis 29 en septembre 2027). Cette formation enseigne donc le Java moderne — records,
classes scellées, pattern matching, virtual threads, switch expressions — et pas seulement
le « Java d'il y a quinze ans ».
Sur l'IDE, cette formation fait un choix assumé : Eclipse. Il faut être honnête sur son
positionnement.
Eclipse IDE est un environnement libre, gratuit et open source (licence EPL 2.0), maintenu
par la Eclipse Foundation avec des releases trimestrielles régulières. Il reste largement
utilisé — en entreprise, dans l'écosystème Jakarta EE, l'embarqué, l'enseignement, et partout
où le libre et l'absence de licence comptent. Mais IntelliJ IDEA domine aujourd'hui le
marché et VS Code progresse vite. Cette formation enseigne Eclipse sérieusement et à fond,
tout en étant transparente sur ce qu'apportent les alternatives — voir
Annexe B — Choisir son IDE : Eclipse vs IntelliJ IDEA vs VS Code.
Trois principes guident donc le contenu :
- ✅ On enseigne le langage Java d'abord : les compétences sont transférables à n'importe quel IDE. Eclipse est l'outil, Java est le métier.
- 🔧 On exploite réellement Eclipse : perspectives, refactorings, débogage, content assist, Maven/Gradle intégrés, et les bonnes extensions du Marketplace.
- 🤖 On intègre le développement assisté par IA, devenu un standard du quotidien (Copilot et assistants dans Eclipse, génération de tests, migration de versions).
Repère de périmètre : cette formation couvre Java SE (le langage et la plateforme) et les
écosystèmes les plus utilisés en 2026 — Spring Boot 4 / Jakarta EE 11, JavaFX/Swing,
JDBC/JPA-Hibernate, build Maven/Gradle, tests JUnit 6. Kotlin, Scala et Android ne
sont évoqués qu'en mise en perspective (voir Annexe B).
| Parcours | Chapitres | Durée estimée |
|---|---|---|
| Débutant | 1-3, 5, 6 | 5-7 jours |
| Développeur Backend / Spring Boot ⭐ | 1-10, 12-17 | 12-15 jours |
| Développeur Desktop (JavaFX/Swing) | 1-7, 9, 11, 14-15 | 9-11 jours |
| Développeur Données / Persistance | 1-4, 6-10, 14 | 8-10 jours |
| Maintenance & Migration Legacy | 1-3, 6, 9-12, Annexe E | 7-9 jours |
| Architecte / Performance 🌳 | 1-4, 8, 13-16, 18 + Annexe B | 12-15 jours |
| IA-First 🤖 | 1-3, 7, 17 | 3-4 jours |
| Formation complète | 1-18 + annexes | 24-30 jours |
- 1.1 Qu'est-ce que Java et à quoi il sert réellement en 2026
- 1.2 JVM, JRE, JDK : qui fait quoi
- 1.3 Le cycle des versions et les LTS 🆕
- Cadence semestrielle (mars / septembre), LTS tous les deux ans (17, 21, 25, 29)
- Java 25 LTS (référence), Java 21 LTS (très répandu), Java 26 (non-LTS)
- Quelle version cibler pour un nouveau projet vs du legacy
- 1.4 Choisir et installer un JDK
⚠️ - Oracle JDK vs distributions OpenJDK : Eclipse Temurin (Adoptium), Azul Zulu, Amazon Corretto, Microsoft, BellSoft Liberica, Red Hat, GraalVM
- Licences (NFTC, OTN, GPLv2+CPE) : éviter les pièges de conformité
- 1.5 Installer et découvrir Eclipse IDE 2026-06 🔧 🆕
- Le package « Eclipse IDE for Java Developers », l'Installer, workspace
- Visite guidée : perspectives, vues, éditeur
- 1.6 Eclipse en 2026 : positionnement honnête ⭐
- Forces d'Eclipse (libre, gratuit, sans licence, écosystème de plugins, Jakarta EE, embarqué)
- Eclipse vs IntelliJ IDEA vs VS Code (grille de décision)
- Pourquoi les compétences Java restent transférables à tout IDE
- L'ère de l'IA : Copilot et assistants dans Eclipse 🤖
- 1.7 Premier projet pas à pas (console)
- 2.1 Structure d'un programme,
main, packages - 2.2 Types primitifs, variables,
var(inférence locale) - 2.3 Opérateurs et expressions
- 2.4 Structures conditionnelles
if/else, l'opérateur ternaireswitch: instruction et expression (->,yield) ⚡pattern matchingduswitchet tests de type ⚡
- 2.5 Boucles et itérations (
for,for-each,while,do-while) - 2.6 Chaînes et texte (
String,StringBuilder, blocs de texte"""…""") ⚡ - 2.7 Tableaux
- 2.8 Entrées/sorties console, lecture clavier
- 2.9 Conventions, indentation et lisibilité (+ formatage Eclipse) 🔧
- 3.1 Classes et objets (champs, méthodes, constructeurs,
this) - 3.2 Encapsulation et modificateurs d'accès (
public/private/protected/package) - 3.3 Héritage et polymorphisme (
extends,@Override,super,final) - 3.4 Classes abstraites et interfaces
- Méthodes
defaultetstaticd'interface, interfaces fonctionnelles
- Méthodes
- 3.5 Records — données immuables modernes ⚡ ⭐
- 3.6 Classes scellées (
sealed/permits) ⚡- Combinées au pattern matching et aux record patterns
- 3.7 Énumérations (
enum) avancées - 3.8 Classes internes, anonymes et locales
- 3.9 Génériques (types et méthodes génériques, bornes, wildcards)
- 3.10
equals/hashCode/toString,Comparable/Comparator - 3.11 Réflexion, annotations et
recordpatterns (notions)
- 4.1 Le framework des collections (
List,Set,Map,Queue,Deque) - 4.2
Optional— gérer l'absence proprement ⚡ - 4.3 Lambdas et références de méthodes ⚡
- 4.4 L'API Stream — un pilier du Java moderne ⭐ ⚡
filter/map/reduce/collect,Collectors, flux parallèles- Nouveautés récentes :
Stream::gather(Stream Gatherers) ⚡
- 4.5 API Date/Heure
java.time(LocalDate,Instant,Duration, fuseaux, formatage) - 4.6 Gestion des exceptions
try/catch/finally,try-with-resources, exceptions vérifiées vs non vérifiées- Hiérarchie, exceptions personnalisées, bonnes pratiques
- 4.7 Mathématiques,
BigDecimal/BigInteger, formatage etLocale
5. Eclipse IDE en profondeur ⭐ 🔧 🆕
- 5.1 Workspaces, perspectives et vues (Package Explorer, Outline, Problems, Console)
- 5.2 Anatomie d'un projet Java (sources,
module-info, classpath, JRE/JDK) - 5.3 L'éditeur de code et le
Content Assist(autocomplétion, quick fixes, templates) - 5.4 Refactorings essentiels (renommer, extraire, déplacer, inline)
- 5.5 Navigation et recherche (Call Hierarchy, Type Hierarchy, Open Type, recherche globale)
- 5.6 Débogage dans Eclipse ⭐
- Points d'arrêt (conditionnels, watchpoints, exception breakpoints)
- Pas-à-pas, variables, expressions, Display, drop to frame, Hot Code Replace
- 5.7 Génération de code et snippets (getters/setters, constructeurs,
toString, templates perso) - 5.8 Intégration Git (EGit) : commit, branches, merge, comparaison
- 5.9 Le Marketplace et les extensions utiles (SonarLint, Spring Tools, etc.)
- 5.10 Eclipse et l'IA : assistants et Copilot dans l'éditeur 🤖
- 5.11 Personnalisation, formateur de code, Save Actions et performances de l'IDE
- 5.12 Raccourcis essentiels → voir Annexe D
- 6.1 Pourquoi un outil de build ; dépendances, dépôts (Maven Central)
- 6.2 Maven (POM, cycle de vie, plugins, scopes) avec l'intégration m2e d'Eclipse 🔧
- 6.3 Gradle (Groovy/Kotlin DSL, tâches) avec l'intégration Buildship d'Eclipse 🔧
- 6.4 Projets multi-modules et gestion des versions
- 6.5 Bibliothèques réutilisables, publication d'artefacts
- 6.6 Reproductibilité et lockfiles ; analyse des dépendances
- 7.1 JUnit 6 (annotations, assertions, cycle de vie, tests paramétrés) ⭐ 🆕
- Exécution et débogage des tests directement dans Eclipse 🔧
- JUnit 6 (GA septembre 2025, baseline Java 17) ; JUnit 5 reste très répandu — points de migration
- 7.2 Mockito (mocks, stubs, vérifications) et AssertJ (assertions fluides)
- 7.3 TDD (Test-Driven Development) en pratique
- 7.4 Tests d'intégration avec Testcontainers (bases de données, brokers et services réels en conteneurs) ⭐
- 7.5 Couverture de code avec JaCoCo
- 7.6 Analyse statique (SpotBugs, PMD, Checkstyle, SonarLint dans Eclipse) 🔧
- 7.7 Génération de tests assistée par IA 🤖
8. Concurrence et parallélisme ⭐ 🔄
- 8.1 Pourquoi la concurrence ;
Thread,Runnable, cycle de vie - 8.2
ExecutorService, pools de threads,Future - 8.3
CompletableFutureet composition asynchrone - 8.4 Virtual threads (Project Loom) ⚡ 🆕 ⭐
- Threads légers, montée en charge des E/S ; pinning résolu pour
synchronizeddepuis Java 24 (JEP 491), vigilance résiduelle (code natif, certaines opérations bloquantes)
- Threads légers, montée en charge des E/S ; pinning résolu pour
- 8.5 Concurrence structurée (
StructuredTaskScope) ⚡ 🆕- API remaniée en Java 25, encore en preview (JEP 505) : durée de vie maîtrisée des sous-tâches
- 8.6 Synchronisation et thread-safety (
synchronized,Lock,Atomic*,volatile) - 8.7 Collections concurrentes (
ConcurrentHashMap, files,CopyOnWrite*) - 8.8 Débogage de code concurrent dans Eclipse (vue Threads, points d'arrêt par thread) 🔧
- 9.1
java.io: flux d'octets et de caractères (InputStream/Reader,OutputStream/Writer) - 9.2
java.nio.file:Path,Files, parcours d'arborescence, watch service - 9.3 Flux bufferisés, compression (
GZIP/Deflate), chiffrement de flux - 9.4 Sérialisation JSON (Jackson, Gson) et XML
- 9.5 CSV, fichiers de configuration, ressources du classpath
- 9.6
⚠️ Sérialisation Java native : risques de sécurité et alternatives⚠️
10. Accès aux données ⭐ 🔄
- 10.1 JDBC (connexions, requêtes paramétrées,
ResultSet, transactions)⚠️ Injection SQL : toujours paramétrer (PreparedStatement)
- 10.2 Pools de connexions (HikariCP)
- 10.3 JPA / Hibernate (Jakarta Persistence) ⭐
- Entités, relations,
EntityManager, JPQL/Criteria - Chargement (lazy/eager), cache, transactions, fetch et performances
- Entités, relations,
- 10.4 Migrations de schéma (Flyway, Liquibase)
- 10.5 Introduction à Spring Data JPA et Jakarta Data
- 10.6 Bases de données et pilotes (PostgreSQL, MySQL/MariaDB, SQLite, H2 en test)
- 10.7 Cache applicatif (Caffeine, Redis, Spring Cache) et cache de second niveau Hibernate
- 11.1 Panorama : JavaFX vs Swing — lequel choisir
- 11.2 JavaFX — l'UI desktop moderne ⭐
- Scènes, nodes, layouts, FXML, Scene Builder
- Liaison de données (properties/bindings), CSS, contrôles
- Configurer JavaFX dans Eclipse (e(fx)clipse, dépendances) 🔧
- 11.3 Swing — maintenir l'existant 🏛️
- Composants, layout managers, événements, le concepteur WindowBuilder 🔧
- 11.4 Concurrence UI (thread d'application, tâches en arrière-plan)
- 11.5 Internationalisation (i18n/l10n, ResourceBundle)
- 11.6 Empaquetage d'une application desktop → voir chapitre 15
12. Web et services ⭐ 🔄
- 12.1 Consommer des API REST (
HttpClientdu JDK, JSON) - 12.2 Spring Boot — le framework dominant ⭐ 🆕
- Spring Boot 4 / Spring Framework 7 ; démarrage, auto-configuration, starters
- Spring Tools for Eclipse (édition, run, Boot Dashboard) 🔧
- REST avec Spring MVC (
@RestController, validation, gestion d'erreurs) - Injection de dépendances, profils, configuration (
application.yml) - Spring Data, Spring Security (intro), documentation OpenAPI
- 12.3 Jakarta EE 11 — l'alternative standardisée
- CDI, Jakarta REST (JAX-RS), Jakarta Persistence, Jakarta Data
- Serveurs : Open Liberty, WildFly, Payara, GlassFish
- 12.4 Servlets, JSP et serveurs d'applications (contexte legacy) 🏛️
- 12.5 Temps réel : WebSocket, Server-Sent Events (notions)
- 12.6 Messagerie asynchrone (Apache Kafka, RabbitMQ, Jakarta Messaging/JMS)
- 12.7 Alternatives modernes : Quarkus, Micronaut, Helidon (mise en perspective)
- 13.1 Journalisation (SLF4J + Logback ou Log4j 2, structured logging)
⚠️ Histoire et leçons de Log4Shell ; bonnes pratiques de configuration
- 13.2 Débogage avancé (débogage distant, conditional breakpoints, logpoints) 🔧
- 13.3 Java Flight Recorder (JFR) et JDK Mission Control
- 13.4 Observabilité (Micrometer, OpenTelemetry, health checks, métriques) — notions
- 14.1 Modèle mémoire de la JVM (pile, tas, metaspace)
- 14.2 Garbage Collection (G1, ZGC, Parallel) : principes et choix
- Tuning de base, drapeaux JVM, lecture des journaux GC
- 14.3 Allocations, fuites mémoire, analyse de heap dump (Eclipse MAT) 🔧
- 14.4 Le compilateur JIT, C1/C2, PGO ; ce que les LTS récentes apportent gratuitement 🆕
- 14.5 Benchmarking fiable avec JMH
- 14.6 Bonnes pratiques de performance en Java
- 14.7 Profilage (VisualVM, async-profiler, JFR) depuis Eclipse 🔧
- 15.1 Empaquetage : JAR, JAR exécutable, fat/uber JAR (Shade, Spring Boot)
- 15.2 Le système de modules (JPMS) :
module-info, lisibilité, services - 15.3 Runtimes sur mesure et installeurs natifs (
jlink,jpackage) 🆕 - 15.4 GraalVM Native Image : binaires natifs, AOT, démarrage instantané ⚡ 🆕
- Compatibilité, configuration de réflexion, intégration Spring Boot/Quarkus
- 15.5 Conteneurisation (Docker, images layered, jib)
- 15.6 CI/CD (GitHub Actions, GitLab CI, Jenkins)
- 15.7 Cloud (essentiels, consommés via SDK) : déploiement, configuration, secrets
- 16.1 Authentification et autorisation (OAuth 2.0 / OIDC, JWT, Spring Security)
- 16.2 Cryptographie (hachage, chiffrement, JCA, gestion des secrets)
- 16.3 OWASP Top 10 pour Java (injection, validation, encodage de sortie, désérialisation)
- 16.4 Dépendances et vulnérabilités (scan, SBOM, OWASP Dependency-Check, Snyk)
⚠️ Conformité (ex. CRA) et veille CVE
- 16.5 Checklist de sécurité Java
- 17.1 Coder en 2026 avec l'IA : ce que ça change pour le développeur Java
- 17.2 Prompting efficace pour du code Java idiomatique
- Préciser la version Java cible, le style, les frameworks (Spring, JUnit…)
- Modèles de prompts prêts à l'emploi
- 17.3 Assistants dans Eclipse, VS Code et en CLI ; agents de code 🔧
- 17.4 Générer des tests, des mocks et de la Javadoc
- 17.5 Migrer du legacy avec l'IA (montée de version Java,
javax→jakarta, OpenRewrite) - 17.6 Déboguer et optimiser avec l'IA (expliquer des erreurs, analyser des stack traces)
- 17.7 Limites et pièges (hallucinations d'API, validation systématique)
⚠️ - 17.8 Intégrer l'IA dans vos applications Java ⭐ 🤖
- Spring AI, LangChain4j ; chat, embeddings, function calling, RAG basique
- Jakarta Agentic AI (perspective)
- 18.1 La feuille de route Java (cadence, projets : Loom, Valhalla, Panama, Leyden)
- 18.2 Stratégie de montée de version (quand et comment passer de LTS en LTS)
- 18.3 Choisir son IDE et son écosystème selon le contexte
- 18.4 Au-delà de Java SE : Kotlin, Scala, Android (mise en perspective)
- 18.5 Communauté, documentation, livres, certifications, formation continue
Rappels condensés : types, collections, Stream API, java.time, pattern matching, concurrence —
le compagnon de référence à garder ouvert.
L'annexe de référence sur le positionnement. Forces et limites de chacun, scénarios d'usage,
migration des habitudes, et pourquoi les compétences Java restent transférables.
Conventions de nommage, Clean Code, organisation des projets, gestion des erreurs et de la
journalisation, et bonnes pratiques avec les assistants IA. 🤖
Raccourcis essentiels, Quick Access (Ctrl+3), templates personnalisés, Save Actions,
extensions recommandées (dont extensions IA).
Stratégies depuis Java 8 / 11 / 17 / 21 vers Java 25 LTS : APIs retirées, breaking changes,
migration javax→jakarta, outillage (OpenRewrite, Eclipse Transformer), checklist.
Terminologie Java/JVM, patterns et architectures, acronymes courants, vocabulaire IA.
Erreurs courantes (classpath, versions, NoClassDefFound…), problèmes Maven/Gradle, soucis Eclipse,
pièges fréquents avec l'IA. 🤖
| Version | Type | Sortie | Statut (juin 2026) |
|---|---|---|---|
| Java 25 | LTS | Septembre 2025 | ✅ Recommandée (maj gratuites jusqu'à sept. 2028) |
| Java 26 | STS | Mars 2026 | |
| Java 27 | STS | Sept. 2026 | |
| Java 21 | LTS | Septembre 2023 | 🔧 Très répandu en production |
| Java 17 | LTS | Septembre 2021 | 🏛️ Encore courant, fin du support gratuit Oracle |
| Java 29 | LTS | Prévue sept. 2027 | 🔮 Prochaine LTS |
| Java 11 / 8 | LTS | 2018 / 2014 | 🏛️ Legacy / maintenance |
Eclipse IDE 2026-06 (4.40) : release trimestrielle de juin 2026 (prochaine : 2026-09 / 4.41).
Écosystème : Spring Boot 4 (Spring Framework 7), Jakarta EE 11, Hibernate 7, JUnit 6.
Quoi installer — et quand — chapitre par chapitre, puis comment l'installer sur Windows et Kubuntu : plugins Eclipse, dépendances Maven/Gradle et serveurs via Docker.
- Moderne : on enseigne le Java de 2026 (records, sealed, pattern matching, virtual threads), pas celui d'il y a quinze ans.
- Honnête sur l'outil : Eclipse enseigné à fond, sans cacher ce qu'apportent IntelliJ IDEA et VS Code (Annexe B).
- Transférable : la priorité au langage ; les compétences valent dans n'importe quel IDE.
- À jour : JDK 25 LTS, Eclipse 2026-06, Spring Boot 4 / Jakarta EE 11.
- IA-first 🤖 : un chapitre complet sur le développement assisté, devenu un standard.
- Pragmatique : build (Maven/Gradle), tests (JUnit 6), persistance (JPA), déploiement réel (natif, Docker, CI/CD), migration de versions.
Durée estimée : ~35-45 h de lecture théorique ; 24-30 jours pour le parcours complet en pratiquant les exemples
Public : développeurs Java débutants à confirmés, équipes de développement et de maintenance
Prérequis : bases en programmation recommandées
- 🆕 Nouveau : spécifique à JDK 25 LTS ou Eclipse 2026-06
- 🔄 Mis à jour : contenu actualisé pour le Java moderne
- ⭐ Cœur Java : compétence essentielle ou point fort idiomatique
- ⚡ Java moderne : fonctionnalité récente du langage (records, sealed, pattern matching, virtual threads…)
- 🔧 Eclipse : astuce ou workflow spécifique à l'IDE
- 🏛️ Legacy / Enterprise : maintenance ou technologie historique (Swing, Servlets/JSP, anciennes versions)
- 🌳 Architecture & performance : sujets pointus pour profils confirmés (perf, mémoire, scalabilité)
⚠️ Attention : point de vigilance (sécurité, compatibilité, conformité)- 🤖 IA : développement assisté par intelligence artificielle
Juin 2026
JDK : 25 LTS (septembre 2025, maj gratuites jusqu'en septembre 2028)
IDE : Eclipse 2026-06 (4.40)
Écosystème : Spring Boot 4 · Jakarta EE 11 · JUnit 6 · Maven / Gradle
Licence : Creative Commons BY-NC-SA 4.0