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 Kotlin du cours Apprentissage du langage Java 25 par l'exemple (octobre 2026), lui-même portage du cours Apprentissage du langage C# 14 avec .NET 10 (octobre 2026), 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 Kotlin d'aujourd'hui :

  • le document utilise Kotlin 2.4 (version 2.4.20, septembre 2026), avec le JDK 25, la dernière version de Java à support long (LTS). Kotlin est un langage de la machine virtuelle Java : il produit le même code intermédiaire que Java et utilise directement toutes ses bibliothèques. Le lecteur du cours Java retrouvera donc les mêmes classes du JDK (fichiers, réseau, threads, dates…) et les mêmes cadriciels (JUnit, Spring, Jackson, Hibernate, Spring Boot), utilisés depuis un autre langage ;
  • là où les deux langages diffèrent, le document ne se contente pas de traduire. Kotlin a des réponses propres à des questions que Java traite autrement : la sûreté vis-à-vis de null inscrite dans le système de types, les propriétés, les classes de données, les fonctions d'extension, la surcharge des opérateurs, les types fonctionnels, les valeurs par défaut des paramètres et les arguments nommés, l'expression [when]. À l'inverse, Kotlin n'a pas d'exceptions contrôlées, ni de membres [static]. Ces différences sont présentées en détail, souvent en comparant le code Kotlin et le code Java ;
  • le chapitre sur la programmation asynchrone change de nature : là où Java utilise les classes [CompletableFuture] et les threads virtuels, Kotlin propose les coroutines, avec les fonctions [suspend], les constructeurs [launch] et [async] et la concurrence structurée. C'est la réponse de Kotlin à l'[async] / [await] du C# du cours d'origine ;
  • les bibliothèques sont celles que l'on utilise aujourd'hui sur la JVM : [JUnit 6] et [kotlin.test] pour les tests, [Spring Framework 7] pour l'injection de dépendances, [Jackson 3] pour JSON, [kotlinx.coroutines] pour les coroutines, le pilote [MySQL Connector/J] pour JDBC, [Hibernate 7] pour la correspondance objet / relationnel et [Spring Boot 4] pour les services web ; les projets sont construits avec [Gradle], dont les scripts sont eux-mêmes écrits en Kotlin.

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 Kotlin. Il procède par l'exemple : plus de deux cents programmes (plus de trois cents fichiers Kotlin), courts pour la plupart, commentés ligne par ligne.

1.1. Kotlin de 2011 à 2026

Kotlin a été présenté en juillet 2011 par la société JetBrains, éditeur de l'IDE IntelliJ IDEA, qui cherchait un langage plus concis et plus sûr que Java pour écrire ses propres outils, mais compatible avec lui : un programme Kotlin est compilé en bytecode, exécuté par la machine virtuelle Java (la JVM), et il peut appeler du code Java comme être appelé par lui. Le nom vient d'une île du golfe de Finlande, proche de Saint-Pétersbourg, où travaillait l'équipe qui l'a conçu.

Les grandes étapes :

  • 2016 : Kotlin 1.0, la première version stable, avec l'engagement de compatibilité qui l'accompagne ;
  • 2017 : Google annonce la prise en charge officielle de Kotlin pour écrire des applications Android ; en 2019, Android devient « Kotlin first » : Kotlin est le langage recommandé pour les nouvelles applications Android ;
  • 2018 : Kotlin 1.3, qui rend stables les coroutines, la réponse de Kotlin à la programmation asynchrone (chapitre 9) ;
  • le langage est développé par JetBrains ; la Kotlin Foundation, fondée en 2017 par JetBrains et Google, veille sur son évolution, dont les étapes font l'objet de propositions publiques (les « KEEP », Kotlin Evolution and Enhancement Process) ;
  • 2024 : Kotlin 2.0, avec un nouveau compilateur, appelé K2, plus rapide et capable de mieux suivre les types dans le code (transtypages intelligents) ;
  • Kotlin cible aussi d'autres plateformes que la JVM : JavaScript, WebAssembly et le code natif (Kotlin/Native, iOS). Ce document ne traite que de Kotlin sur la JVM ;
  • depuis la version 2.0, une version du langage (2.1.0, 2.2.0, 2.3.0, 2.4.0…) paraît tous les six mois environ ; entre deux, une version d'outillage (2.x.20) apporte des améliorations des outils et de la bibliothèque standard, sans changer le langage. Ce document utilise la version 2.4.20, parue en septembre 2026. Les nouveautés apparaissent souvent d'abord comme expérimentales : il faut alors les activer explicitement (option du compilateur, ou annotation [@OptIn]) avant qu'elles ne deviennent stables dans une version suivante.

Le tableau suivant résume les principales nouveautés du langage présentées dans ce document et indique le chapitre où elles apparaissent :

Version
Année
Principales nouveautés
Chapitre
Kotlin 1.0
2016
sûreté vis-à-vis de null, propriétés, classes de données, fonctions d'extension, lambdas, [when], surcharge des opérateurs
3, 4, 7
Kotlin 1.1
2017
alias de types [typealias], références liées [objet::fonction], coroutines (expérimentales)
4, 7
Kotlin 1.3
2018
coroutines stables, fonction [main] sans paramètre
2, 3, 9
Kotlin 1.4
2020
interfaces fonctionnelles [fun interface], conversions SAM des interfaces Kotlin
7
Kotlin 1.5
2021
types non signés ([UInt]…) et classes [value class] stables, interfaces scellées
3, 4
Kotlin 1.9
2023
opérateur [..<], propriété [entries] des énumérations, [data object]
3, 12
Kotlin 2.0
2024
compilateur K2 : transtypages intelligents plus précis
4
Kotlin 2.2
2025
conditions de garde dans [when] ([is Int if x > 0 ->]), interpolation avec plusieurs [$]
3, 5
Kotlin 2.3
2025
prise en charge de Java 25
2
Kotlin 2.4
2026
en version 2.4.20, le lanceur [kotlinr] remplace la commande [kotlin]
2

Du côté des bibliothèques et des outils, les nouveautés présentées sont notamment : l'outil de construction [Gradle] et ses scripts en Kotlin ([build.gradle.kts]), les collections de la bibliothèque standard de Kotlin et ses fonctions d'ordre supérieur, les séquences, les coroutines et les flux ([Flow]), ainsi que les grands cadriciels de l'écosystème Java utilisés depuis Kotlin : 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, le compilateur [kotlinc], Gradle) ;
  • chapitre 3 : les bases du langage (types, sûreté vis-à-vis de null, opérateurs, [if] et [when], boucles, exceptions, énumérations, paramètres des fonctions) ;
  • chapitre 4 : les classes, les propriétés, l'héritage, les classes scellées, la surcharge des opérateurs, les interfaces, les génériques, les classes de données, les fonctions d'extension ;
  • chapitre 5 : les classes Kotlin d'usage courant : chaînes, tableaux, collections, séquences, 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 types fonctionnels, 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 les coroutines ;
  • 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], SMTP) ;
  • 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 utilisées par les projets Gradle.

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 sous-projet Gradle 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 [kotlin-oct-2026], avec un sous-dossier par chapitre. Chaque sous-dossier est un projet Gradle (ou une construction Gradle de plusieurs projets) que l'on ouvre tel quel dans IntelliJ IDEA :

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

Chaque petit programme est un fichier Kotlin, rangé dans un paquetage qui porte son nom ([src/main/kotlin/bases04/Bases04.kt], paquetage [bases04]). On l'exécute dans IntelliJ IDEA par le triangle vert placé à côté de sa fonction [main], ou en ligne de commande par Gradle ([gradlew -q run -Pmain=bases04.Bases04Kt], chapitre 2). Les programmes qui ont besoin d'une bibliothèque extérieure (Jackson, JUnit, Spring, le pilote MySQL, Hibernate, Spring Boot) la déclarent dans le fichier [build.gradle.kts] de leur projet : Gradle la télécharge depuis le dépôt Maven Central lors de la première construction.

Tous les programmes du document ont été compilés sans erreur ni avertissement par le compilateur Kotlin 2.4.20, avec l'option qui transforme tout avertissement en erreur ([allWarningsAsErrors]), puis exécutés sur le JDK 25. 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 compilateur Kotlin et du JDK (messages des exceptions) sont en anglais : ils n'ont pas de traduction française ;
  • les exemples ont été exécutés sous Linux. Pour l'essentiel, cela ne change rien : Kotlin sur la JVM est multiplateforme. Les quelques différences (chemins de fichiers avec des / au lieu de \, commandes du terminal, [./gradlew] au lieu de [gradlew]) 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.