Le langage Kotlin
Partie 3 sur 4
7La sûreté vis-à-vis de null
7.1Deux sortes de types
En Kotlin, un type ordinaire, comme String, ne peut jamais valoir null. Pour autoriser l’absence de valeur, il faut ajouter un point d’interrogation : String?. Le compilateur interdit alors d’utiliser directement la valeur : il faut d’abord traiter le cas où elle manque (figure 1).
!! désactive cette protection.7.2Les outils du quotidien
- l’appel sûr
?.n’effectue l’opération que si la valeur existe, et donnenullsinon ; - l’opérateur Elvis
?:, nommé ainsi parce que, tourné de côté, il évoque la mèche du chanteur, fournit une valeur de remplacement ; - la conversion intelligente (en anglais smart cast) : après un test
if (tel != null), le compilateur sait queteln’est plus nul dans ce bloc ; letexécute un bloc seulement si la valeur existe :tel?.let { appeler(it) };- l’opérateur
!!affirme que la valeur n’est pas nulle, et plante dans le cas contraire. Il réintroduit le risque qu’on voulait éviter ; son usage doit rester exceptionnel et justifié.
7.3La frontière avec Java
Java ne distingue pas les types nuls et non nuls. Quand Kotlin reçoit une valeur d’une méthode Java, il ne sait pas si elle peut être nulle : il lui attribue un type de plateforme, noté String! dans les messages du compilateur, sur lequel il ne fait pas de vérification. C’est la faille du dispositif : une NullPointerException peut encore survenir à la frontière entre les deux langages. Les bibliothèques Java bien conçues ajoutent des annotations, comme @Nullable et @NonNull, que Kotlin sait lire ; les bibliothèques d’Android en sont largement pourvues. À défaut, on déclare explicitement le type attendu, nul ou non, dès la réception de la valeur.
8Les coroutines
Une application mobile passe son temps à attendre : une réponse du réseau, une lecture dans la base de données, un calcul. Si elle attend sur le fil d’exécution qui dessine l’écran, celui-ci se fige ; Android affiche même un message proposant de fermer l’application. Il faut donc lancer ces attentes en arrière-plan, ce qui, avec les outils classiques, conduisait à un code compliqué, fait de fonctions de rappel imbriquées.
Les coroutines de Kotlin permettent d’écrire ce code comme s’il était séquentiel. Une fonction marquée suspend peut se mettre en pause en attendant un résultat, sans bloquer le fil d’exécution, puis reprendre là où elle en était :
suspend fun chargerProfil(id: Int): Profil {
val utilisateur = api.utilisateur(id) // attend le réseau, sans bloquer
val photos = api.photos(id)
return Profil(utilisateur, photos)
}
// dans un écran Android
viewModelScope.launch {
val profil = chargerProfil(42)
afficher(profil)
}
Pour lancer plusieurs attentes en parallèle, on utilise async, puis await pour récupérer les résultats (exercice 6). Les coroutines suivent le principe de la concurrence structurée : chaque coroutine est lancée dans une portée, comme viewModelScope, liée à la durée de vie d’un écran ; quand l’utilisateur quitte l’écran, toutes les coroutines de cette portée sont annulées automatiquement. Fini les téléchargements orphelins qui continuent à consommer batterie et réseau. Les flux (Flow) prolongent ce modèle pour les données qui arrivent en continu, comme les positions données par le récepteur de localisation ou les messages d’une conversation.
Comment une fonction peut-elle se mettre en pause sans bloquer un fil d’exécution ? Le compilateur Kotlin transforme chaque fonction suspend en une machine à états : il découpe la fonction à chaque point de suspension, et range dans un petit objet, appelé continuation, les variables locales et l’endroit où reprendre. Quand le résultat attendu arrive, la bibliothèque des coroutines rappelle la fonction avec cette continuation, et l’exécution repart au bon endroit, éventuellement sur un autre fil. Une coroutine en attente ne coûte donc que quelques dizaines d’octets, ce qui permet d’en avoir des centaines de milliers, comme les goroutines de Go (voir Go).
Pour s’exercer
Exercice 4 : une fonction d’extension
Écrivez une fonction d’extension estPair() sur le type Int, puis utilisez-la pour garder les nombres pairs d’une liste.
Voir la réponse
fun Int.estPair(): Boolean = this % 2 == 0
val pairs = listOf(3, 8, 5, 12, 7).filter { it.estPair() } // [8, 12]
Dans le corps de la fonction, this désigne l’entier sur lequel on l’appelle. La fonction n’est pas réellement ajoutée à la classe Int : c’est une fonction ordinaire, que le compilateur permet d’appeler avec la syntaxe d’une méthode. Elle n’a donc accès qu’aux éléments publics du type.
Exercice 5 : une chaîne de traitements
À partir de la liste val villes = listOf("lyon", "metz", "brest", "lille", "pau"), obtenez, en une expression, la liste des villes de plus de trois lettres, avec une majuscule initiale, triées par ordre alphabétique.
Voir la réponse
val resultat = villes
.filter { it.length > 3 }
.map { it.replaceFirstChar { c -> c.uppercase() } }
.sorted()
// [Brest, Lille, Lyon, Metz]
Chaque fonction renvoie une nouvelle liste, sans modifier la précédente. « pau » est écartée par le filtre. Pour de très grandes collections, on peut écrire villes.asSequence() au début de la chaîne : les traitements sont alors appliqués élément par élément, sans créer de listes intermédiaires.
Exercice 6 : attendre en parallèle
La fonction chargerProfil de la section 8 appelle successivement api.utilisateur et api.photos, qui prennent chacune une seconde. Combien de temps dure-t-elle ? Comment la rendre plus rapide ?
Voir la réponse
Environ deux secondes : la seconde requête ne part qu’après la réponse à la première. Les deux étant indépendantes, on peut les lancer en même temps :
suspend fun chargerProfil(id: Int): Profil = coroutineScope {
val utilisateur = async { api.utilisateur(id) }
val photos = async { api.photos(id) }
Profil(utilisateur.await(), photos.await())
}
La fonction dure alors environ une seconde. coroutineScope garantit la concurrence structurée : si l’une des deux requêtes échoue, l’autre est annulée automatiquement, et l’erreur est transmise à l’appelant.
Exercice 7 : la conversion intelligente
Pourquoi le premier fragment est-il accepté et le second refusé ?
// Fragment A
fun taille(t: Any): Int = if (t is String) t.length else 0
// Fragment B
class Boite { var contenu: String? = null }
fun taille(b: Boite): Int = if (b.contenu != null) b.contenu.length else 0
Voir la réponse
Dans A, après le test t is String, le compilateur sait que t est un texte et autorise t.length : c’est la conversion intelligente. Dans B, contenu est une propriété modifiable (var) d’un objet : entre le test et l’utilisation, un autre fil d’exécution pourrait la remettre à null. Le compilateur refuse donc la conversion. On écrit plutôt b.contenu?.length ?: 0, ou l’on copie d’abord la valeur dans une variable locale, val c = b.contenu, qui, elle, ne peut pas changer entre le test et l’usage.