Introduction au langage Kotlin

Ce tutoriel est une introduction au langage Kotlin pour les développeurs connaissant déjà le langage Java (ou autre langage orienté objet).

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Présentation et installation

I-A. Présentation

Le langage Kotlin est un langage développé par JetBrains, entreprise conceptrice de l'EDIEnvironement de Développement Intégré Intellij Idea entre autres. Cependant il est open-source.

Ses principaux avantages résident dans la simplification du code pour de nombreuses tâches courantes (par exemple, la création de POJOPlain Old Java Object), une sécurité de code accrue grâce à un contrôle stricte de la nullité des valeurs, et une courbe d'apprentissage relativement faible (au moins pour les développeurs ayant déjà des prérequis en Java ou en POOProgrammation Orientée Objets de manière générale).

Le langage Kotlin est un langage qui a plusieurs déclinaisons :

  • une version visant une interaction avec le langage Java, et qui est compilé en bytecode afin d'être exécuté sur la JVMJava Virtual Machine ou sur les périphériques Android,
  • une version visant à être compilée pour le langage Javascript,
  • une version dite native, visant à être compilée directement en exécutable indépendant de toute plateforme d'interprétation.

Ce tutoriel a pour objectif l'enseignement de la version pour la JVM, même s'il ne devrait pas être ardu de passer à l'une des deux autres versions.

Il vise principalement les développeurs étant familiers avec le langage Java et la POO : même si tout langage impératif et orienté objet devrait convenir.

I-B. Installation

Nous allons ici aborder l'installation du langage Kotlin, même s'il ne s'agit pas d'une installation proprement dite, étant donné que nous passons par l'outil Gradlel'outil de compilation Gradle afin de récupérer les dépendances, compiler le programme et l'exécuter de manière automatique.

Sachez également qu'il est possible de tester les codes directement en ligneTester les codes avec la page Try Kotlin (y compris pour les projets incluant plusieurs fichiers).

Ce tutoriel se basera sur l'éditeur Intellij IdeaEditeur Intellij Idea (la version Community est gratuite), mais est adaptable à tout éditeur capable de gérer les projets Gradle. Sachez aussi que pour mieux gérer les différentes versions et mises à jour d'Intellij Idea, vous disposez aussi du programme gratuit JetBrain Toolboxl'outil JetBrain Toolbox.

Par ailleurs, ce tutoriel est basé sur la version 1.2.10 de Kotlin et la version d'Intellij Idea Community 2017.2.4.

Afin d'installer l'environnement de développement, nous pouvons procéder comme suit :

  1. Nous utiliserons Kotlin à travers la JVM : nous avons donc besoin d'installer Java correspondant à notre Système d'Exploitation, si ce n'est déjà fait : Page de téléchargement du SDK Java 8Page de téléchargement de Java 8 (la version 8 de Java devrait être amplement suffisante),
  2. Nous pouvons installer la version d'Intellij Idea Community correspondant à notre système (ou passer par la JetBrains Toolbox afin de mieux gérer les mises à jour),
  3. Afin de bénéficier de la coloration syntaxique et de la vérification syntaxique du code par l'EDI, nous pouvons aussi installer le plugin Kotlin. Pour cela cliquez d'abord sur le bouton Configure dans l'accueil (fig 1.1), et choisissez le menu Plugins. Il se peut que vous ne soyez pas dans la fenêtre d'accueil, mais qu'un projet soit déjà chargé : dans ce cas il suffit simplement de refermer le projet (menu File→Close project) pour revenir à l'acceuil. Cliquez alors sur le bouton Browse repositories ... (fig 1.2). Cherchez le plugin Kotlin et installez-le (fig 1.3), puis cliquez sur Restart Intellij IDEA (puis validez avec Ok puis Restart) une fois que cela est fait afin de prendre en compte les mises à jour.
Bouton configure
Fig. 1.1 Bouton configure
Bouton browse repositories
Fig. 1.2 Bouton browse repositories
Plugin kotlin
Fig. 1.3 Plugin kotlin

I-C. Première prise en main

Nous allons créer un simple programme affichant « Bonjour, les développeurs ! » depuis Intellij Idea en Kotlin, sans rien installer de plus : grâce au logiciel Gradle intégré dans notre EDI.

I-C-1. Création du projet

  1. Démarrez un nouveau projet de type Gradle dans Intellij Idea : notez bien qu'il vous faudra éventuellement préciser le chemin de votre SDK Java. Vérifiez également que le projet soit uniquement de type Java (fig 1.4),
  2. Dans la fenêtre suivante, entrez com.developpez dans le champ GroupId (c'est le nom de domaine de l'application) et HelloWorld dans le champ ArtifactId (nom d'application),
  3. La plupart des paramètres par défaut de la 3e fenêtre devraient convenir :

    1. Cochez « Use auto-import » si ce n'est déjà fait
    2. Un module séparé par ensemble de sources
    3. Ne pas générer les fichiers du projet de manière externe
    4. L'exécutable Gradle par défaut doit convenir aussi
  4. Le nom du projet proposé est le même que l'ArtifactId renseigné dans la 2e fenêtre : il peut rester tel quel.
Projet de type java et gradle
Fig. 1.4 Projet de type java et gradle

I-C-2. Téléchargement automatique des dépendances

Maintenant remplacez le contenu du fichier build.gradle (ce qui nous sert à configurer la compilation via Gradle) par ceci :

Configuration de la configuration via Gradle (build.gradle)
TéléchargerCacherSélectionnez

Lorsque vous sauvegarderez ce fichier, Gradle téléchargera automatiquement (ou mettra à jour) les dépendances déclarées.

I-C-3. Ajout du fichier source et exécution

  1. Il nous faut d'abord créer le dossier Kotlin, même s'il sera automatiquement reconnu en tant que dossier source. Sélectionnez le dossier main dans la vue explorateur de fichiers (fig 1.5) et lancer son menu contextuel (bouton droit de la souris). Sélectionnez le menu New → Directory. Nommez le dossier kotlin (attention à la casse!).
  2. Lancez le menu contextuel sur le dossier kotlin juste créé et sélectionnez le menu New → Kotlin File/Class… et entrez le nom Hello (sans extension). Notez que le menu Kotlin File/Class… ne sera visible que si le plugin kotlin est activé.
  3. Entrez le code suivant dans le fichier Kotlin.kt :
Hello.kt
TéléchargerCacherSélectionnez
Configuration automatique des dépendances via Gradle
Fig. 1.5 Configuration automatique des dépendances via Gradle

Avant d'exécuter le code, voici quelques remarques :

  • Il n'y a pas obligation de terminer une instruction par un point-virgule,
  • C'est le mot-clé fun qui permet de déclarer une fonction,
  • La fonction main doit être déclarée comme acceptant un tableau de String et sans valeur de retour,
  • Remarquez également qu'en Kotlin un tableau est une classe générique (Array),
  • Également une déclaration se constitue d'abord du nom de la variable et ensuite du type,
  • La fonction println, disponible immédiatement et sans aucun import, permet d'afficher du texte à l'écran et sans aucun retour à la ligne. C'est l'équivalent de l'appel fastidieux System.out.printlnde Java,
  • Enfin, ce code n'a pas déclaré de classe : contrairement au Java où toute fonction doit être membre d'une classe. Il n'y aucun package déclaré non plus. Elle sera donc déclarée dans une classe nommée HelloKt, qui représente l'ensemble des déclarations au niveau du fichier Hello.kt. D'où la déclaration de classe principale HelloKt dans notre configuration Gradle.

Pour exécuter le code, il suffit de double-cliquer sur la tâche Gradle application→run (fig 1.6). Notre texte s'affiche donc à l'écran après compilation (fig 1.7). Notez que vous aurez peut-être besoin de basculer la vue exécution en mode texte (fig 1.7 étape 2), et que vous pourrez directement relancer l'exécution à l'aide du bouton vert (fig 1.7 étape 4).

Exécution de l'application
Fig. 1.6 Exécution de l'application

II. Bases du langage

II-A. Déclarations de variables

En Kotlin, on distingue les variables dont on peut changer la valeur, et les variables immuables qui ne sont pas tout à fait des constantes :

  • le mot-clé val permet de déclarer une variable immuable,
  • le mots-clé var permet de déclarer une variable altérable.
 
Sélectionnez
val nom:String = "Toto"
// nom = "Dodo" // Interdit !!! Car nom a été déclaré avec val
var age = 10
age += 12 // aucun problème car age est altérable.

Pour rappel, il faut préciser le type de variable après le nom, et pas avant comme en Java.

Evidemment, une variable immuable doit être intialisée lors de sa déclaration.

Cela fonctionne aussi bien pour les types « primitifs » (tout est objet en Kotlin) que pour les types personnels.

 
Sélectionnez
class Personne(val nom : String, var age : Int = 10)

val jean:Personne = new Personne("Jean", 25)

Même si les classes en Kotlin seront expliquées ultérieurement, sachez qu'ici la classe Personne dispose d'une propriété nom en lecture-seule, et d'une propriété age en lecture-écriture, dont la valeur par défaut est 10. (Notez bien cependant qu'ici la classe Personne n'a pas défini de méthode mutatrice, mais si c'était le cas, il aurait aussi été probable que la variable jean puisse voir son état modifié bien qu'ayant été déclarée comme val ! Ici le mot-clé val empêche juste de changer l'objet pointé par jean.)

II-B. Types de base

Les types numériques Byte, Short, Int, Long, Float, et Double sont équivalents aux types existants en Java : si ce n'est que, pour rappel, en Kotlin, tout est objet. Ainsi on peut écrire :

 
Sélectionnez
2.toString()
10.downTo(0) // génère le range (c'est à dire l'intervalle) décroissant   de 10 à 0.

Le type String dispose des mêmes méthodes qu'en Java, mais aussi des méthodes supplémentaires. Ainsi on peut écrire :

 
Sélectionnez
println("martin".all{it.isLowerCase()}) // Teste si le mot entier est en basse casse.

La méthode all, permettant de tester si tous les éléments d'une collection remplissent un critère, n'existe pas en Java : c'est une extension du langage Kotlin. Le morceau de code constitué par les accolades est une fonction anonyme (ou lambda) : il en sera question ultérieurement.

Kotlin ajoute aussi le type Range (intervalle), très utile.

Ainsi on peut notamment exécuter une boucle grâce à un objet Range (en effet, la syntaxe basique Java pour effectuer une boucle n'existe pas en Kotlin) :

 
Sélectionnez
for (i <- 3..7){
    println(i)
} // Affiche les chiffres de 3 à 7 sur plusieurs lignes.

Mais on peut aussi obtenir une intervalle décroissant avec downTo :

 
Sélectionnez
for (i <- 10 downTo 0) {
    println(i)
} // Compte à rebours de 10 à 0, sur plusieurs lignes.

Il est aussi possible de préciser une progression autre que 1

 
Sélectionnez
for (i in 2..36 step 3) println(i) // Affiche les nombres 2,5,8,…,35

Il est aussi possible de combiner un intervalle décroissant et une progression définie.

 
Sélectionnez
for (i in 36 downTo 2 step 3) println(i) // Affiche les nombres 36,33,…,3

Sachez aussi, comme nous le verrons plus tard avec les fonctions, le type void n'existe pas en Kotlin, mais on utilise à la place le type Unit (qui ne s'applique pas qu'aux fonctions).

N'oubliez pas que vous pouvez vous rendre compte des méthodes disponibles pour un objet donné dans le playground Kotlin ou dans l'IDE Intellij Idea grâce à la commande CTRL+ESPACE après avoir saisi le point accolé à l'objet.

II-C. Inférence de type

Dans de nombreuses situations, le compilateur Kotlin est capable de reconnaître le type d'une variable grâce à l'expression qui a servi à l'initialiser.

 
Sélectionnez
val age = 10 // age est déclaré comme Int
val nom = "Toto" // nom est déclaré comme String
var prix = 10.2 // prix est déclaré comme Double

Il va de soi que pour une variable non initialisée de suite (donc de type var), il faut en préciser le type : l'inférence de type ne pouvant s'appliquer dans ce cas.

De même l'inférence de type fonctionne aussi avec les types complexes : qu'ils soient définis par Kotlin ou par nous-même.

 
Sélectionnez
class Personne(val name: String)
val jean = Personne("Jean") // jean est de type Personne.

Nous verrons par la suite d'autre inférence de type.

II-D. Expressions

Toute instruction qui retourne une valeur constitue une expression : simple valeur littérale (3, "Toto", …), expression arithmétique ou booléenne, appel de fonction (même une fonction ne retournant aucune valeur exploitable : c'est-à-dire une fonction définie comme retournant Unit), déclaration d'une fonction anonyme, … Ces expressions peuvent donc être utilisées pour initialiser des variables.

 
Sélectionnez
val message = if (age < 18) "C'est un mineur !" else "Il est majeur." // Se référer à la section suivante sur les structures de contrôle.

Certaines instructions ne retournent jamais de valeur : c'est le cas pour la boucle while, comme nous le verrons dans la section suivante.

 
Sélectionnez
val resultat = while(i < 10) {i += 1} // Strictement interdit !!!

Par ailleurs les affectations de variables ne sont pas des expressions : il est donc impossible de les enchaîner au sein d'une même instruction.

 
Sélectionnez
var b = 0
val a = b= 10 // Strictement interdit !!!

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Laurent Bernabe. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.