Comment assurer la sécurité des types en Kotlin…

La sécurité des types en Kotlin est assurée à la compilation grâce à plusieurs mécanismes clés :

Système de types non nullables : Kotlin distingue entre les types référentiels pouvant accepter la valeur null (indiqués par ? à la fin du nom du type) et ceux qui ne peuvent pas. Le compilateur exige des vérifications explicites de null ou l'utilisation d'appels sécurisés (?.) et d'opérateurs (?:, !!).

// Référence qui ne peut pas être null
val nonNullableString: String = "Hello"

// Référence qui peut être null
var nullableString: String? = "World"
nullableString = null // Permis

// Erreur de compilation : gestion du null requise
// val length = nullableString.length

// Appel sécurisé
val length: Int? = nullableString?.length

// Opérateur Elvis
val safeLength: Int = nullableString?.length ?: 0

Casts intelligents (Smart Casts) : Le compilateur convertit automatiquement le type d'une variable dans les blocs if, when, while, for et autres expressions après vérification du type ou du null.

fun printLength(obj: Any) {
    if (obj is String) {
        // Dans ce bloc, le compilateur sait que obj est String
        println("Longueur de String est ${obj.length}")
    }
}

fun processNullableString(str: String?) {
    if (str != null) {
        // Dans ce bloc, le compilateur sait que str n'est pas null
        println("String n'est pas null, longueur est ${str.length}")
    }
}

Types génériques (Generics) : Kotlin supporte les génériques, permettant de créer des classes, interfaces et fonctions qui fonctionnent avec différents types, assurant la sécurité des types en temps de compilation.
```
class Box<T>(val item: T)

fun printItem(box: Box<String>) {
    // Le compilateur sait que item est de type String
    println(box.item.uppercase())
}
```

Covariance (out) et contravariance (in) : Permettent de préciser comment les sous-types peuvent être utilisés dans des types génériques, évitant les erreurs d'incompatibilité de types en compilation.

interface Source<out T> {
    fun nextT(): T
    // fun consumeT(t: T) // Erreur de compilation
}

interface Sink<in T> {
    // fun produceT(): T // Erreur de compilation
    fun consumeT(t: T)
}

Classes scellées (Sealed classes) : Représentent une hiérarchie limitée de classes, où toutes les sous-classes sont connues en temps de compilation. Cela permet au compilateur de vérifier l'exhaustivité des expressions when avec les sous-classes de classes scellées, garantissant la gestion de tous les cas possibles.

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val code: Int) : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Données : ${result.data}")
        is Result.Error -> println("Erreur : ${result.code}")
        // Sans 'else', le compilateur garantit la gestion de toutes les sous-classes de Sealed
    }
}

Ces mécanismes fonctionnent ensemble, permettant de détecter de nombreuses erreurs potentielles liées aux types à un stade précoce du développement, avant l'exécution de l'application.

Comment assurer la sécurité des types en Kotlin?