Les Variables en Kotlin

Introduction aux variables

Les variables servent à stocker des éléments de données qui peuvent être, selon le besoin, mutables ou immuables. La valeur contenue dans une variable peut appartenir à différents types de données, tels que des числа, des caractères ou des chaînes de caractères.

Syntaxe des variables

Pour déclarer des variables en Kotlin, on utilise les mots-clés `var` et `val` :

var x: Type = mutableValue
val y = readOnlyValue

Le mot-clé `var` est destiné aux variables dont la valeur peut changer, tandis que `val` est réservé aux variables dont la valeur demeure constante. La variable peut aussi être typée explicitement, comme le montre l'exemple avec `x`. On peut également laisser le compilateur inférer le type, comme avec `y`.

Types nullable et non-nullable

À la différence d'autres langages de programmation, Kotlin ne possède pas de type null. Au lieu de cela, il distingue les types nullable et non-nullable. Un type nullable peut contenir une valeur null, tandis qu'un type non-nullable ne peut pas. Pour indiquer qu'un type est nullable, l'opérateur `?` est ajouté après le type, par exemple :

fun main() {
    // Déclaration d'une variable nullable
    var z: String? = null
}

Propriétés déléguées

Kotlin propose également des propriétés déléguées, qui permettent de déléguer le comportement de la variable à un objet délégué au lieu de le stocker directement dans la classe. Voici un exemple d'une propriété déléguée :

import kotlin.reflect.KProperty

class Example {
    var prop: String by Delegate()
}

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "${'$'}thisRef, merci pour la délégation de '${'$'}{property.name}' !"
    }
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("${'$'}value a été assigné à '${'$'}{property.name}' dans ${'$'}thisRef.")
    }
}

Exemple d'utilisation des propriétés déléguées

Voici comment on peut utiliser les classes `Example` et `Delegate` dans un programme :

fun main() {
    val example = Example()
    example.prop = "Bonjour"
    println(example.prop)
}

Cette sortie affiche : "Bonjour a été assigné à 'prop' dans Example@1be83a0e. Example@1be83a0e, merci pour la délégation de 'prop' à moi !"

Lorsque la valeur de `prop` est modifiée, la fonction `setValue` de la classe `Delegate` est appelée, ce qui produit un message. À l'inverse, lorsque la valeur de `prop` est récupérée, on appelle la méthode `getValue()`, qui renvoie une chaîne.

Conclusion

Les propriétés déléguées représentent une fonctionnalité puissante et flexible de Kotlin qui peut être exploitée pour implémenter divers design patterns, tels que le motif observateur ou le motif proxy. Elles permettent également de simplifier le code en abstraire des tâches communes liées aux propriétés, comme l'initialisation paresseuse ou l'accès sûr en cas de multithreading.