Le type Nullable

Qu’est-ce que le type nullable ?

Dans de nombreux langages de programmation, quand on déclare une variable sans pour autant l’initialiser (lui donner une valeur), elle prend ce qu’on appelle une valeur par défaut.

Ces valeurs par défaut dépendent du langage et du type de la variable. Par exemple, en Java, si l’on regarde du côté des types primitifs, la valeur par défaut d’un booléen est false, la valeur par défaut d’un entier est 0, etc. Toujours en Java, la valeur par défaut d’un objet est généralement null.

Le langage Kotlin est un peu différent de Java. En effet, en Kotlin, il n’est pas possible de simplement déclarer une variable. Celle-ci doit absolument être initialisée lors de sa déclaration.

Par exemple, le code suivant ne compile pas :

fun main() 
{ 
 var name: String 
 println(name) 
} 

Si l’on tente de lancer ce programme, le message d’erreur suivant s’affiche :

Variable ‘name' must be initialized. 

Il convient donc de modifier la variable name afin de l’initialiser lors de sa déclaration ou un peu plus tard dans le programme. La question que l’on peut maintenant se poser est : avec quelle valeur doit-on initialiser cette variable ? Avec une chaîne de caractère...

Indiquer des éléments nullables

Par sa syntaxe, Kotlin impose aux développeurs de savoir si la variable ou l’attribut de classe qu’ils manipulent peut être null ou non. Pour cela, il existe une notation particulière.

Il suffit d’ajouter le symbole ? au type de la variable pour que celle-ci puisse prendre la valeur null :

fun main() 
{ 
 var dog: Dog? = null 
 
 if (/* condition */) 
 { 
   dog = Dog("Doggo") 
 } 
 
 println(dog) 
} 

Le programme compile maintenant avec succès.

Ce concept de type nullable peut être utilisé partout où l’on manipule des types. Voyons quelques exemples.

Un attribut de classe peut être nullable :

data class Dog(val name: String, var tatoo: String?) 

Ici, l’attribut tatoo peut aussi bien accepter la valeur null qu’une chaîne de caractères :

val doggo = Dog("Doggo", null) 
val heyden = Dog("Heyden", "ABC-123") 

Le paramètre d’une fonction peut également être nullable :

data class Dog(val name: String, private var tatoo: String?) 
{ 
 
 fun doTatoo(tatoo: String?) 
 { 
   //... 
 } 
 
} 

Dernier exemple, une fonction peut également renvoyer...

Composer avec les éléments nullables

Nous pouvons sécuriser nos programmes en précisant que certains éléments peuvent être nullables. Mais pour des raisons de sécurité, un élément nullable ne peut pas être manipulé comme un élément non nullable.

Soit la classe Dog suivante :

data class Dog(val name: String) 
{ 
 
 fun bark() 
 { 
   println("Waf! Waf!") 
 } 
 
} 

Ce programme permet d’initialiser un objet de la classe Dog si un chiffre tiré au hasard est pair :

fun main() 
{ 
 var dog: Dog? = null 
 
 if (getRandomNumber() % 2 == 0) 
 { 
   dog = Dog("Doggo") 
 } 
 
 dog.bark() 
} 
 
/** 
* Returns a random number between 1 and 100 
*/ 
fun getRandomNumber(): Int = 
   (1..100).random() 

Si l’on essaie de compiler ce programme, il refuse de se lancer et affiche l’erreur suivante :

Only safe (?.) or non-null asserted (!!.) calls are allowed on 
a nullable receiver of type Dog? 

Cette erreur se produit sur la ligne dog.bark(). En effet, Kotlin n’est pas "content" car on tente d’appeler la méthode bark sur un objet dog qui potentiellement a pour valeur null. Ce n’est pas permis. On ne peut pas demander à un chien qui, finalement, n’existe pas, d’aboyer.

Dans le message d’erreur, Kotlin nous donne des indications sur la façon de corriger ce problème. Cela passe l’utilisation de deux opérateurs : !! et ?.