Le langage Kotlin
Partie 2 sur 4
4Premiers pas
On écrit généralement du Kotlin dans IntelliJ IDEA ou dans Android Studio, l’environnement de développement d’Android, qui en dérive ; on peut aussi l’essayer dans le navigateur, sur le site officiel du langage. Le programme minimal :
fun main() {
println("Bonjour, le monde !")
}
Pas de classe obligatoire, pas de point-virgule, pas de public static void : fun déclare une fonction, et main est le point de départ. Les projets sont construits par l’outil Gradle, dont les fichiers de configuration s’écrivent eux-mêmes en Kotlin.
5Les bases du langage
5.1val et var
Kotlin distingue deux sortes de variables : val, dont la valeur ne peut plus changer, et var, modifiable. L’usage est de préférer val partout où c’est possible, ce qui rend le code plus facile à suivre. Le type est déduit de la valeur, mais on peut l’écrire après le nom (voir les variables).
val ville = "Lyon" // String, non modifiable
var compteur = 0 // Int, modifiable
compteur++
val prix: Double = 9.5
println("À $ville, le billet coûte $prix euros")
La dernière ligne montre les gabarits de chaînes : une variable précédée de $, ou une expression entre ${…}, est insérée directement dans le texte.
5.2Fonctions et expressions
Les paramètres peuvent avoir des valeurs par défaut et être nommés à l’appel, ce qui évite de multiplier les variantes d’une même fonction. Une fonction courte peut s’écrire sur une ligne, avec le signe =. Comme if, l’instruction when, qui remplace avantageusement le switch de Java, est une expression qui produit une valeur :
fun tarif(age: Int, reduction: Boolean = false): Double {
val base = when {
age < 12 -> 4.0
age < 26 -> 6.5
else -> 9.5
}
return if (reduction) base * 0.8 else base
}
fun carre(x: Int) = x * x
tarif(30) // 9.5
tarif(30, reduction = true) // 7.6
5.3Collections et lambdas
La bibliothèque standard distingue les collections en lecture seule (listOf, mapOf) et modifiables (mutableListOf…), et propose de nombreuses fonctions qui prennent en paramètre une lambda, une petite fonction anonyme écrite entre accolades. Dans une lambda à un seul paramètre, celui-ci s’appelle it :
val notes = listOf(12, 7, 15, 9, 18)
val admis = notes.filter { it >= 10 } // [12, 15, 18]
val moyenne = notes.average() // 12.2
val mentions = notes.map { if (it >= 16) "TB" else "-" }
5.4Les fonctions d’extension
Kotlin permet d’ajouter une fonction à un type existant, même à une classe de Java qu’on ne peut pas modifier, sans héritage. La fonction s’utilise ensuite comme une méthode ordinaire :
fun String.initiales(): String =
split(" ").filter { it.isNotEmpty() }.joinToString("") { it.first().uppercase() }
"ada lovelace".initiales() // "AL"
Les bibliothèques d’Android utilisent abondamment ce mécanisme pour offrir des écritures plus agréables au-dessus des anciennes interfaces Java.
5.5Les erreurs
Kotlin utilise les exceptions de Java, avec try, catch et throw, mais supprime une obligation de Java : les exceptions dites « vérifiées », que Java impose de déclarer ou d’attraper, n’existent pas en Kotlin. Ce choix allège le code, mais reporte sur le programmeur la responsabilité de penser aux erreurs possibles (voir les exceptions). La bibliothèque standard propose aussi le type Result et la fonction runCatching, qui transforment une exception en valeur à examiner, ainsi que des fonctions de vérification comme require et check, qui lèvent une exception claire quand une condition n’est pas remplie :
val age = runCatching { saisie.toInt() }
.getOrElse { 0 } // 0 si la saisie n'est pas un nombre
val n = saisie.toIntOrNull() ?: 0 // même résultat, sans exception
Pour s’exercer
Exercice 1 : null ou pas null ?
Quelles lignes sont refusées par le compilateur ? Corrigez-les.
val nom: String = null var ville: String? = "Metz" val n = ville.length val m = ville?.length val k: Int = ville?.length
Voir la réponse
Trois lignes sont refusées. val nom: String = null : un String ne peut pas valoir null ; il faut écrire String?. ville.length : ville est de type String?, on doit écrire ville?.length. val k: Int = ville?.length : l’expression est de type Int?, puisqu’elle vaut null si ville est nulle ; on écrit val k: Int = ville?.length ?: 0. La quatrième ligne est correcte : m est de type Int?.
6Classes et objets
6.1Classes et propriétés
Une classe Kotlin déclare ses propriétés directement dans son constructeur (voir la programmation orientée objet). Les accesseurs sont générés automatiquement, et l’on peut les personnaliser. Différence notable avec Java : les classes et les méthodes sont fermées par défaut ; pour permettre qu’on en hérite, il faut les déclarer open. Ce choix évite des héritages imprévus, source de fragilité.
open class Compte(val titulaire: String) {
var solde: Double = 0.0
private set // modifiable seulement dans la classe
fun deposer(montant: Double) {
require(montant > 0) { "Montant invalide" }
solde += montant
}
}
6.2Les classes de données
Une data class sert à représenter des données. Le compilateur lui ajoute automatiquement une comparaison par contenu (equals), un affichage lisible (toString), et une méthode copy pour créer une version modifiée sans toucher à l’original (exercice 2).
6.3Les classes scellées
Une sealed class, ou une sealed interface, déclare une famille fermée de cas, connue du compilateur. Combinée à when, elle permet de vérifier qu’aucun cas n’est oublié, comme les énumérations de Rust ou les unions de TypeScript :
sealed interface Etat {
object Chargement : Etat
data class Succes(val articles: List<String>) : Etat
data class Erreur(val message: String) : Etat
}
fun afficher(e: Etat) = when (e) {
Etat.Chargement -> "Chargement…"
is Etat.Succes -> "${e.articles.size} articles"
is Etat.Erreur -> "Erreur : ${e.message}"
}
Ce motif est omniprésent dans les applications Android modernes, pour décrire l’état d’un écran. Le mot-clé object déclare un objet unique, sans avoir à écrire de classe ; il remplace aussi les membres static de Java, grâce aux objets compagnons.
6.4Interfaces et délégation
Comme Java, Kotlin propose des interfaces, qui peuvent contenir des méthodes avec un comportement par défaut. Il ajoute un mécanisme qui favorise la composition plutôt que l’héritage : la délégation. Avec le mot-clé by, une classe déclare qu’elle implémente une interface en confiant le travail à un autre objet, et ne réécrit que ce qu’elle veut changer :
interface Journal { fun ecrire(message: String) }
class JournalConsole : Journal {
override fun ecrire(message: String) = println(message)
}
class JournalHorodate(private val base: Journal) : Journal by base {
override fun ecrire(message: String) =
base.ecrire("${java.time.LocalTime.now()} $message")
}
Le même mot-clé permet de déléguer une propriété : val config by lazy { chargerConfig() } ne calcule la valeur qu’au premier accès, puis la garde en mémoire. C’est d’ailleurs ce mécanisme qu’utilise Jetpack Compose avec by remember (section 9.1).
Pour s’exercer
Exercice 2 : les classes de données
Avec data class Client(val nom: String, val courriel: String, val age: Int), que valent a == b et c ?
val a = Client("Léa", "lea@example.org", 31)
val b = Client("Léa", "lea@example.org", 31)
val c = a.copy(age = 32)
Voir la réponse
a == b vaut true : pour une classe de données, == compare le contenu, propriété par propriété, et non l’identité des objets. Avec une classe ordinaire, sans data, le résultat serait false, car ce sont deux objets distincts. c est un nouvel objet Client(nom=Léa, courriel=lea@example.org, age=32) ; a n’est pas modifié. Cette façon de travailler sur des données non modifiables, en créant des copies, évite les modifications inattendues d’un objet partagé.
Exercice 3 : un cas oublié
On ajoute à l’interface scellée Etat de la section 6.3 un nouveau cas, data class HorsLigne(val depuis: Long) : Etat. Que se passe-t-il pour la fonction afficher ?
Voir la réponse
Le compilateur refuse la fonction : l’expression when doit couvrir tous les cas d’une interface scellée, et HorsLigne n’est pas traité. Le message indique précisément le cas manquant. Il faut ajouter une branche, par exemple is Etat.HorsLigne -> "Hors ligne depuis ${e.depuis} s". C’est l’intérêt des classes scellées : un oubli, qui provoquerait en Java un comportement incorrect silencieux, devient une erreur de compilation. Il faut donc éviter d’ajouter une branche else par facilité, qui supprimerait cette vérification.