Initiez-vous à Kotlin

Commençons par la base du langage Kotlin, à savoir la déclaration de variables. En Java, vous avez probablement l’habitude d’écrire le code suivant afin de déclarer vos variables :

String question = "What's your name?";
String answer = "A girl has no name.";

Eh bien, en Kotlin, la manière de déclarer une variable change un petit peu… ;)

L’exemple ci-dessous vous montre trois façons de déclarer une variable de type chaîne de caractères (ou "String") en Kotlin.

// 1
val question = "What's your name?"

// 2 
val question: String = "What's your name?"

// 3 
var question: String = "What's your name?"

Comme vous pouvez le deviner en lisant ces précédentes lignes de code, nous pouvons déclarer en Kotlin une variable grâce aux mots-clés  val  et  var  :

• val  (pour valeur) : La référence de votre variable sera immuable, c’est-à-dire que vous ne pourrez pas la modifier une fois que vous l’aurez initialisée. En fait, c’est tout simplement l’équivalent du mot-clé  final  en Java ! Votre variable pointera donc toujours vers la même référence en mémoire.

• var  (pour variable) : La référence de votre variable sera muable, c’est-à-dire que vous pourrez modifier le contenu de votre variable même après son initialisation. C’est l’état par défaut de toutes les variables en Java. Votre variable pointera donc vers une référence en mémoire, mais celle-ci pourra être remplacée par une autre si nécessaire.

De manière générale, Kotlin nous invite fortement à déclarer toutes nos variables en immuable (donc via le mot-clé  val  ) afin de rendre notre code le plus proche possible du style de la programmation fonctionnelle, limitant ainsi un maximum les fameux "effets de bord".

Je vois que vous suivez ! Eh bien, comme nous l’avons dit précédemment, le compilateur de Kotlin possède une fonctionnalité appelée "l’inférence de type", ou "type inference", en anglais. Pour que cela soit plus parlant, comprenez par "inférence" la notion de "déduction" !

Kotlin se voulant être un langage très intelligent, ses développeurs ont souhaité lui offrir les avantages de lisibilité des langages "dynamiquement typés", mais sans leurs inconvénients. En effet, pour Kotlin, ce sera au moment de la compilation (et non au moment de l’exécution) que les types de vos variables seront automatiquement déduits.

D’ailleurs, si vous le désirez, vous pouvez également spécifier le type de chaque variable grâce aux deux points  :   suivis du type que vous souhaitez lui définir, comme nous l’avons fait dans le précédent exemple (2 et 3).

val name: String = "Phil"
val age: Int = 27
val isDeveloper: Boolean = true

équivaut à :

val name = "Phil"
val age = 27
val isDeveloper = true

Et pour finir, même si je pense que vous avez déjà dû le remarquer, nous n’avons pas eu besoin du point-virgule pour indiquer la fin de notre ligne de code (ou "instruction"). C’est en quelque sorte la cerise sur le gâteau... ;)

Soyons subtils !

Comme nous venons de le voir, une variable déclarée avec le mot-clé  val  sera obligatoirement immuable et donc considérée comme telle. En revanche, vous n’êtes pas obligé de l’initialiser à la même ligne que là où vous l’avez déclarée :

val message: String 

if (isUserHappy()){
    message = "Glad you're so happy! :D"
} else {
    message = "What's going on? :("
}

Vous devez simplement avoir en tête que vous devez initialiser ce genre de variable dans le même bloc de code que là où vous l’avez déclarée, comme dans l’exemple précédent.

Ne soyons pas nuls…

Eh non ! Rappelez-vous, Kotlin est un langage dit "sûr". Derrière cet adjectif réconfortant se cache en réalité un ensemble de fonctionnalités améliorant la sûreté du langage, dont la fameuse "Null Safety".

Tant mieux ! Laissez-moi vous expliquer : en Java, je suis persuadé que vous avez déjà eu affaire à l’erreur  java.lang.NullPointerException  . Comme vous le savez, cette erreur intervient lorsque vous tentez d’accéder à une variable égale à  null .

Malheureusement, en Java, une des seules solutions pour gérer "proprement" cette erreur est d’utiliser l’annotation  @Nullable  afin de forcer notre IDE à déclencher une alerte pour nous rappeler de faire attention quand nous manipulons la variable en question.

En Kotlin, nous allons faire tout l’inverse et embrasser complètement cette erreur ! :D D’ailleurs, par défaut, les variables en Kotlin ne supportent pas la contenance d’une valeur nulle, à moins que vous ne l’ayez explicitement autorisée.

Tout à fait ! Et cela va BEAUCOUP nous aider dans l’écriture d'un programme sûr. En effet, le fait de déclarer explicitement qu’une variable PEUT "contenir une valeur nulle" va nous permettre de vérifier systématiquement celle-ci quand nous essayons de la manipuler ! Avec ce mécanisme, on évite quasiment toutes les erreurs  java.lang.NullPointerException  ... :)

Ainsi, pour réaliser cela en Kotlin, nous allons simplement utiliser le point d'interrogation  ?  , juste après le type de la variable.

var message: String? = "My message can possibly be null!"
message.toUpperCase()

Comme vous le voyez sur l’exemple ci-dessus, nous avons déclaré la variable  message  comme pouvant "possiblement" contenir une valeur nulle. Puis, lorsque nous souhaitons ensuite accéder à sa méthode  toUpperCase() , le compilateur Kotlin nous souligne en rouge le point précédant cette méthode pour nous dire que cela est impossible, car la variable peut être possiblement nulle.

Tout à fait, mais nous avons tout de même indiqué cette variable comme pouvant être possiblement nulle à un moment donné dans l’exécution de notre programme. Le compilateur Kotlin lève donc une erreur pour nous le rappeler.

En indiquant une variable comme pouvant "possiblement" contenir une valeur nulle, vous indiquez aux autres développeurs que cette variable pourra sûrement contenir une valeur nulle : ils devront donc absolument prendre leurs précautions en la manipulant.

Ainsi, nous aurons plusieurs moyens de gérer dans notre code ce genre de variable :

var message: String? = "My message can possibly be null!"
message?.toUpperCaset()

ou...

var message: String? = "My message can possibly be null!"
if (message != null) message.toUpperCase()

La première façon de gérer une variable possiblement nulle est d’utiliser là encore le point d’interrogation afin d’appeler une de ses méthodes de manière sécurisée.

Dès lors, si jamais la variable est égale à nulle, la méthode ne sera tout simplement pas appelée ! En revanche, si la variable contient bien une valeur, alors la méthode sera appelée et exécutée... :)

La deuxième façon de gérer une variable possiblement nulle est d’utiliser une simple condition, comme nous pouvons le faire en Java. Petite subtilité tout de même : après la condition, vous ne serez pas obligé d’utiliser le point d’interrogation, car le compilateur de Kotlin aura compris que la variable en question ne peut être QUE différente de nulle… ;) #IlEstIntelligentCeCompilateur

Soyons à l’aise !

Afin de nous faciliter encore plus la vie, Kotlin nous permet de manipuler un peu plus simplement les variables de type  String  . Nous allons pouvoir, par exemple, utiliser le symbole  $  afin de faire référence à une variable locale directement à l’intérieur d’un autre  String  :

val name = "Phil"
print("Hello $name")

// Output : Hello Phil

Cela peut s’avérer très pratique pour afficher des messages de débogages directement dans la console de notre IDE, sans utiliser l’habituelle concaténation.

Soyons constants !

Imaginez maintenant que vous souhaitiez créer une constante dans votre programme. En Java, cela donnait généralement quelque chose comme ça :

public static final String SERVER_URL = "https://my.api.com";

Eh bien, laissez-moi vous dire quelque chose d’assez perturbant... En Kotlin, le mot-clé  static  n’existe plus ! 😱Mais pas de panique, nous verrons une alternative à ce léger "problème" dans le chapitre "Améliorez vos fonctions" de la dernière partie.

Ainsi, voici comment nous déclarons l’équivalent sous Kotlin :

const val SERVER_URL: String = "https://my.api.com"

Le mot-clé  const  précédant le mot-clé  val  nous permet de définir une constante dont la valeur sera connue au moment de la compilation. Celle-ci ne pourra bien évidemment pas être modifiée lors de l’exécution de votre programme (et c’est tout l’intérêt !).

Soyons cools !

Comme nous l’avons vu un peu plus haut, pour déclarer une variable muable (qui peut être modifiée après son initialisation), nous allons utiliser le mot-clé  var  . So far, so good... :)

Imaginez maintenant que vous ne souhaitiez pas initialiser votre variable immédiatement après sa déclaration, mais le faire un peu plus tard dans votre code (quand par exemple une page ou un écran a terminé de charger).

Si vous écrivez la ligne suivante, Kotlin refusera de compiler :

Mais alors, comment le feriez-vous en Kotlin ?

Essayons pour voir :

var username: String? = null

Bonne approche ! Mais cela veut dire que vous autorisez le fait que cette variable puisse contenir une valeur nulle, et dans notre exemple, nous ne le souhaitons pas… ;)

Vous allez tout simplement utiliser le mot-clé  lateinit  (pour "Late-Initialized") permettant d’indiquer à Kotlin que vous êtes sûr et certain d’initialiser la variable en question, un peu plus tard dans votre code :

private lateinit var submitButton: Button 

// Info : onCreate() est appelée une fois que l'écran est affiché (Android)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    submitButton = this.getSubmitButton()
}

Pratique, n’est-ce pas ? :p

Practice Makes Perfect!

La théorie, c'est bien, mais la pratique, c'est encore mieux ! Justement, nous vous avons concocté un petit exercice interactif de fin de chapitre pour appliquer toutes ces nouvelles connaissances.

• 🎓Un petit exercice, ça vous tente ? C'est par ici que ça se passe.

• 🎁Déjà terminé ? Le corrigé se trouve juste ici.

En résumé

• Le mot-clé  val  permet de créer une variable dont la référence sera immuable (qui ne peut pas être modifiée après son initialisation).

• Le mot-clé  var  permet de créer une variable dont la référence sera muable (qui peut être modifiée après son initialisation).

• Kotlin ne vous oblige pas à mentionner le type d’une variable lors de sa déclaration (grâce à l’inférence de type).

• Une variable  val  doit être initialisée dans le même bloc de code que celui où elle a été déclarée.

• Vous pouvez définir une variable comme pouvant contenir une valeur nulle grâce au point d’interrogation  ? .

• Une constante se définit grâce au mot-clé  const  suivi du mot-clé val  .

• Vous pouvez définir une variable comme étant "initialisable plus tard" dans votre code grâce au mot-clé  lateinit  .

Pour aller plus loin :

• KotlinLang : Null Safety, Basic Syntax, String Template

Vous savez maintenant déclarer et initialiser des variables en Kotlin, bravo ! Suivez-moi dans le chapitre suivant pour implémenter différentes fonctions.