Skip to content

1. Introduction

Le PDF du document est ICI.

Les codes du document sont ICI.

Ce document est un produit de l'IA Claude d'Anthropic. C'est le portage en Java du cours Apprentissage du langage C# 14 avec .NET 10 (octobre 2026), lui-même réécriture du cours Apprentissage du langage C# version 3.0 avec le framework .NET 3.5 écrit par Serge Tahé en mai 2008. Il en reprend le plan, les exemples et le fil rouge, et les écrit dans le Java d'aujourd'hui :

  • le document utilise Java 25 (septembre 2025), la dernière version de Java à support long (LTS), et présente au fil des chapitres les nouveautés du langage, des fichiers source compacts de Java 25 aux threads virtuels de Java 21 en passant par les records, les classes scellées et le filtrage par motif ;
  • là où les deux langages diffèrent, le document ne se contente pas de traduire : les propriétés, les structures, la surcharge des opérateurs ou les délégués de C# n'existent pas en Java, qui a ses propres réponses (accesseurs, records, interfaces fonctionnelles) ; à l'inverse, Java a des notions qui lui sont propres, comme les exceptions contrôlées ou les threads virtuels, et elles sont présentées en détail ;
  • deux chapitres changent de nature : la programmation asynchrone, que Java aborde avec les classes [CompletableFuture] et les threads virtuels plutôt qu'avec des mots clés [async] / [await], et la correspondance objet / relationnel, assurée par Hibernate, l'ORM le plus utilisé du monde Java ;
  • les bibliothèques sont celles que l'on utilise aujourd'hui en Java : [JUnit 6] pour les tests, [Spring Framework 7] pour l'injection de dépendances, [Jackson 3] pour JSON, le pilote [MySQL Connector/J] pour JDBC, [Hibernate 7] et [Spring Boot 4] pour les services web ; les projets sont construits avec [Maven].

Ce document n'est pas un cours exhaustif. Comme ceux dont il est issu, il est destiné à des personnes connaissant déjà la programmation et qui veulent découvrir les bases de Java. Il procède par l'exemple : plus de deux cents programmes (plus de trois cents fichiers Java), courts pour la plupart, commentés ligne par ligne.

1.1. Java de 1995 à 2026

Java a été rendu public par Sun Microsystems en mai 1995. Il repose sur une idée qui a fait son succès : le compilateur [javac] ne produit pas du code machine mais un code intermédiaire, le bytecode, rangé dans des fichiers [.class], que la machine virtuelle Java (la JVM, « Java Virtual Machine ») exécute en le compilant à la volée en code machine. Un même programme compilé s'exécute ainsi sous Windows, Linux ou macOS : « write once, run anywhere ». Les langages Kotlin, Scala ou Groovy produisent eux aussi du bytecode et utilisent les mêmes bibliothèques.

Les grandes étapes :

  • 2006-2007 : OpenJDK. Sun publie le code du JDK sous licence libre (GPL). Toutes les distributions actuelles de Java sont construites à partir d'OpenJDK ;
  • 2010 : Oracle rachète Sun et devient le principal contributeur de Java ;
  • 2014 : Java 8, une version charnière : expressions lambda, API Stream, nouvelle API des dates ([java.time]). Beaucoup de programmes en production sont encore écrits dans ce style ;
  • depuis 2017 (Java 9) : une nouvelle version de Java paraît tous les six mois, en mars et en septembre. Certaines versions sont à support long (LTS, « Long-Term Support ») : Java 11 (2018), 17 (2021), 21 (2023) et 25 (septembre 2025), utilisée dans ce document ; depuis Java 17, il en paraît une tous les deux ans. Les autres versions ne sont maintenues que six mois ; les nouveautés y apparaissent souvent d'abord en « aperçu » (« preview »), avant d'être finalisées dans une version suivante ;
  • le JDK est distribué par plusieurs fournisseurs, tous construits à partir d'OpenJDK et équivalents pour notre usage : Oracle, la fondation Eclipse (Eclipse Temurin, projet Adoptium), Microsoft, Amazon (Corretto), les distributions Linux.

Le langage a beaucoup évolué depuis Java 8. Le tableau suivant résume les principales nouveautés présentées dans ce document et indique le chapitre où elles apparaissent :

Version
Année
Principales nouveautés
Chapitre
Java 8
2014
expressions lambda, références de méthodes, API Stream, méthodes [default] des interfaces, [java.time], [CompletableFuture]
5, 7, 9
Java 9
2017
modules (JPMS), [jshell], collections non modifiables [List.of], [Map.of]
2, 4, 5
Java 10
2018
inférence du type des variables locales [var]
3
Java 11
2018
client HTTP [java.net.http.HttpClient], exécution directe d'un fichier source [java Fichier.java], méthodes [strip], [repeat], [lines] des chaînes
2, 5, 12
Java 14
2020
expressions [switch] ([case ->], [yield]), messages détaillés des [NullPointerException]
3, 4
Java 15
2020
blocs de texte ["""]
3
Java 16
2021
records, filtrage par motif avec [instanceof]
4
Java 17
2021
classes et interfaces scellées ([sealed], [permits])
4
Java 18
2022
UTF-8 comme encodage par défaut
5
Java 21
2023
threads virtuels, collections séquencées, filtrage par motif dans [switch], motifs de records
3, 4, 5, 8, 9
Java 22
2024
variables et paramètres anonymes [_], lancement de programmes de plusieurs fichiers source
3, 4, 7
Java 24
2025
collecteurs intermédiaires des flux ([Gatherers])
5, 7
Java 25
2025
fichiers source compacts et méthodes [main] d'instance, classe [IO], importation de modules, valeurs à portée ([ScopedValue])
2, 3, 8

Du côté des bibliothèques et des outils, les nouveautés présentées sont notamment : l'outil de construction [Maven], les collections modernes, l'API Stream, l'API [java.nio.file] des fichiers, les classes de [java.util.concurrent], le client HTTP de Java 11, et les grands cadriciels de l'écosystème : JUnit, Spring, Jackson, Hibernate et Spring Boot.

1.2. Le contenu du document

Le document comprend les chapitres suivants :

  • chapitre 2 : l'installation de l'environnement de travail (JDK 25, IntelliJ IDEA ou VS Code, Maven, les commandes [java] et [javac]) ;
  • chapitre 3 : les bases du langage (types, opérateurs, instructions de contrôle, exceptions contrôlées et non contrôlées, énumérations, passage de paramètres) ;
  • chapitre 4 : les classes, les records, les interfaces, l'héritage, les classes scellées, les génériques, les paquetages, le filtrage par motif ;
  • chapitre 5 : les classes Java d'usage courant : chaînes, tableaux, collections, API Stream, fichiers texte et binaires, JSON avec Jackson, expressions régulières ;
  • chapitre 6 : les architectures en couches, les tests unitaires avec JUnit 6 et l'injection de dépendances avec Spring ;
  • chapitre 7 : les interfaces fonctionnelles, les expressions lambda et les événements ;
  • chapitre 8 : les threads d'exécution, la synchronisation et les threads virtuels ;
  • chapitre 9 : la programmation asynchrone avec [CompletableFuture] et les threads virtuels ;
  • chapitre 10 : l'accès aux bases de données avec JDBC ;
  • chapitre 11 : Hibernate ;
  • chapitre 12 : la programmation Internet (TCP/IP, clients et serveurs TCP, HTTP avec [HttpClient]) ;
  • chapitre 13 : les services web avec Spring Boot ;
  • chapitre 14 : pour aller plus loin ;
  • annexes : l'installation de Laragon et de MySQL, les dépendances Maven utilisées.

1.3. Le fil rouge : le calcul de l'impôt

Un même problème est repris tout au long du document : le calcul de l'impôt sur le revenu d'un contribuable n'ayant que son salaire à déclarer. Le barème utilisé est celui du cours d'origine (revenus 2003) : il n'est plus d'actualité, mais il suffit à notre propos, qui est d'écrire la même application de plusieurs façons. Elle est construite en neuf versions :

Version
Chapitre
Contenu
1
3
un programme unique : saisies validées, calcul, affichage
2
4
des classes et des interfaces : [TrancheImpot], [IImpot], [AbstractImpot], [HardwiredImpot]
3
5
les données du calcul lues dans un fichier texte ou un fichier JSON
4
6
une architecture en couches [dao], [metier], [ui] dans un seul programme
5
6
un module Maven par couche, des tests unitaires et l'intégration des couches par injection de dépendances
6
10
une couche [dao] qui lit les données dans une base MySQL avec JDBC
7
11
une couche [dao] écrite avec Hibernate
8
12
un serveur TCP de calcul de l'impôt et son client
9
13
un service web REST de calcul de l'impôt, un client console et un client web

À partir de la version 5, les versions suivantes réutilisent les couches de la version 5 et ne remplacent que la couche qui change : c'est tout l'intérêt de l'architecture en couches présentée au chapitre 6.

1.4. Les exemples

Les codes du document sont rangés dans un unique dossier [java-oct-2026], avec un sous-dossier par chapitre :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
java-oct-2026/
├── 02-installation/       premier programme, premiers projets Maven
├── 03-bases/              Bases01.java à Bases31.java, Impots1.java
├── 04-classes/            Classes01.java à Classes26.java, programmes de plusieurs fichiers, ImpotsV2
├── 05-classes-java/       chaînes, tableaux, collections, API Stream, fichiers, JSON, regex, ImpotsV3
├── 06-architectures/      TestsDemo, ImpotsV4, ImpotsV5 (couches, tests, injection de dépendances)
├── 07-lambdas/            Lambdas01.java à Lambdas11.java
├── 08-threads/            Threads01.java à Threads31.java
├── 09-async/              Async01.java à Async26.java
├── 10-jdbc/               scripts SQL, projet jdbc (Jdbc01 à Jdbc10), ImpotsV6
├── 11-hibernate/          projets Hibernate, ImpotsV7
├── 12-internet/           Internet01.java à Internet19, ImpotsV8
└── 13-services-web/       services web Spring Boot et leurs clients (WsImpot, ClientWsImpot : version 9)

Les petits programmes sont des fichiers source compacts : un simple fichier [.java], exécuté par la commande [java Fichier.java] (chapitre 2). Les programmes de plusieurs fichiers qui n'utilisent que les bibliothèques du JDK sont lancés de la même façon. Les programmes qui ont besoin d'une bibliothèque extérieure (Jackson, JUnit, Spring, le pilote MySQL, Hibernate, Spring Boot) sont des projets Maven ([pom.xml]).

Tous les programmes du document ont été compilés sans erreur ni avertissement par le compilateur [javac] du JDK 25, avec l'option [-Xlint:all] qui active tous les avertissements, et exécutés avec les versions des bibliothèques indiquées en annexe. Les résultats reproduits dans le document sont ceux de ces exécutions. Ils ont été obtenus avec la langue et le pays français (fr-FR), comme sur un poste Windows français : les nombres réels formatés s'affichent avec une virgule décimale et les dates en français. Deux remarques :

  • les messages d'erreur du JDK (messages des exceptions, messages du compilateur) sont en anglais : le JDK n'en fournit pas de traduction française ;
  • les exemples ont été exécutés sous Linux. Pour l'essentiel, cela ne change rien : Java est multiplateforme. Les quelques différences (chemins de fichiers avec des / au lieu de \, commandes du terminal) sont signalées là où elles apparaissent.

Les résultats des programmes multithreads, asynchrones ou réseau, ainsi que les durées mesurées, peuvent varier d'une exécution à l'autre : les commentaires portent sur ce qui est reproductible.

1.5. Les sources

Les sources principales de ce document sont :

https://stahe.github.io
Ce cours, rédigé par l’IA d’Anthropic Claude à la demande de Serge Tahé, est mis à la disposition du public selon les termes de la licence Creative Commons Attribution – Pas d’utilisation commerciale – ShareAlike 3.0 Unported.