Gestion des erreurs en Kotlin : try/catch, null safety et classes sealed

Gestion des erreurs en Kotlin : try/catch et bien plus

La gestion des erreurs est l'une des tâches clés lors de l'écriture d'un code fiable et robuste. Kotlin, en tant que langage de programmation moderne, offre aux développeurs plusieurs outils puissants pour travailler avec les exceptions et les situations imprévues. Dans cet article, nous allons détailler le mécanisme classique try/catch, les particularités de la null safety, ainsi que les approches avancées : l'utilisation de Result et des sealed classes. Ce contenu sera utile aussi bien aux débutants qu'aux programmeurs expérimentés souhaitant structurer leurs connaissances.

1. Le try/catch classique en Kotlin

Kotlin est entièrement compatible avec Java et prend en charge le bloc traditionnel try/catch/finally. Cependant, il existe des différences importantes : en Kotlin, les exceptions sont unchecked (non vérifiées), ce qui signifie que le compilateur ne vous oblige pas à les gérer. Cela rend le code plus concis, mais nécessite de l'attention.

La syntaxe est la suivante :

try {    // Code qui peut lever une exception    val result = riskyOperation()    println("Résultat : $result")} catch (e: Exception) {    // Gestion de l'exception    println("Une erreur est survenue : ${e.message}")} finally {    // Le bloc s'exécute dans tous les cas    println("Fin de l'opération")}

En Kotlin, try peut être utilisé comme une expression retournant une valeur :

val number: Int? = try {    "123".toInt()} catch (e: NumberFormatException) {    null}println(number) // Affiche : 123

C'est particulièrement pratique lorsqu'on a besoin d'obtenir un résultat ou une valeur par défaut sans variables superflues.

2. Null Safety : prévention des erreurs au niveau des types

L'une des principales fonctionnalités de Kotlin est la null safety. Le langage résout le problème du NullPointerException dès la phase de compilation. Les types en Kotlin sont divisés en nullable (peuvent être null) et non-null (ne peuvent pas).

Exemple :

var name: String = "Kotlin"  // Ne peut pas être null// name = null // Erreur de compilation !

var nullableName: String? = "Kotlin" // Peut être nullnullableName = null // Fonctionne

Pour travailler en toute sécurité avec les types nullable, Kotlin propose plusieurs opérateurs :

• ?. (safe call) — exécute l'opération uniquement si la valeur n'est pas null :

val length = nullableName?.length // Si null, alors null




• ?: (elvis operator) — retourne une valeur par défaut si l'objet est null :

val length = nullableName?.length ?: 0




• !! (not-null assertion) — affirme que la valeur n'est pas null (à utiliser avec prudence) :

val length = nullableName!!.length // Si null — exception

L'utilisation de la null safety au lieu de try/catch pour les vérifications de null rend le code plus lisible et plus sûr.

3. Utilisation de Result pour une approche fonctionnelle

Kotlin fournit une classe intégrée Result<T>, qui représente le résultat d'une opération pouvant se terminer avec succès ou par une erreur. C'est une alternative à try/catch, basée sur la programmation fonctionnelle.

Exemple d'utilisation :

fun riskyDivision(a: Int, b: Int): Result<Int> {    return runCatching {        a / b    }}

fun main() {    val result = riskyDivision(10, 0)

    result.onSuccess { value ->        println("Succès : $value")    }.onFailure { error ->        println("Erreur : ${error.message}")    }

    // Ou on peut obtenir la valeur avec une valeur par défaut    val value = result.getOrDefault(0)    println("Valeur : $value")}

runCatching est une fonction wrapper pratique qui intercepte toutes les exceptions et retourne un Result. Vous pouvez combiner Result avec des chaînes d'appels, ce qui