Tutoriel sur le langage Kotlin

Introduction (partie 1/4)

Dans cet article en plusieurs parties, vous allez être initié aux bases du langage Kotlin.

Cet article vise principalement les développeurs étant familiers avec le langage Java et la POO, même si tout langage orienté objet devrait convenir. Je ferai de temps en temps référence à Java pour essayer d’aider à visualiser certains concepts.

La version de Kotlin utilisée lors de l’écriture de l’article était la version 1.3.70.

Voici les différentes parties:

Introduction rapide

Bases de la syntaxePartie 2

Fonctions et notions sur les classesPartie 3

Notions avancées sur les classes et diverses fonctionnalitésPartie 4

Cette première partie présente de manière succincte le langage ainsi que son utilisation dans l’éditeur officiel en ligne.

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum.Commentez Donner une note  l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Avantages du langage Kotlin

Le langage Kotlin est un langage open source développé par JetBrains, entreprise conceptrice de l’ EDI IntelliJ Idea entre autres.

Ses principaux avantages, pour reprendre les arguments du site officiel, 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 plus strict que Java (notamment pour la nullité des valeurs) ;
  • et une facilité d’interaction vers et à partir du langage Java et avec la JVMJava Virtual Machine — ce qui permet notamment la réutilisation directe de la plupart des codes écrits en Java.

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

  • une version visant une intégration avec le langage Java, et qui est compilée en bytecode afin d’être exécutée sur la JVMJava Virtual Machine ou sur les périphériques Android ;
  • une version visant à être compilée vers JavaScript ;
  • une version dite native, visant à être compilée directement en exécutable indépendant de toute plateforme.

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

II. Prise en main rapide

Vous pouvez, si vous le souhaitez, tester les différents codes du tutoriel dans l’éditeur en ligne officiell'éditeur officiel. Il vous permettra, avec une simple connexion, d’organiser plusieurs projets.

À titre d’exemple, nous allons coder une application qui indique la position du mois de l’année donné en argument. La zone pour renseigner les arguments dans l’éditeur se situe au-dessus du code.

Et le bouton d’exécution est le bouton Run au-dessus du code.

L'éditeur en ligne et le bouton run
L'éditeur en ligne et le bouton run
Les mois de l’année
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
fun positionDuMoisDemande(mois: String) : Int {
    val positions = mapOf<String, Int>(
        "Janvier" to 1,
        "Février" to 2,
        "Mars" to 3,
        "Avril" to 4,
        "Mai" to 5,
        "Juin" to 6,
        "Juillet" to 7,
        "Août" to 8,
        "Septembre" to 9,
        "Octobre" to 10,
        "Novembre" to 11,
        "Décembre" to 12
    )
    
    if (mois !in positions) throw IllegalArgumentException()
    return positions[mois]!!
}

fun main(args: Array<String>) {
    if (args.size == 0) {
        println("Il faut préciser le mois en argument !")
        return
    }
    val mois = args[0].trim()
    try {
        println("Ce mois est à la position ${positionDuMoisDemande(mois)} dans l'année.")
    } catch (e: IllegalArgumentException) {
        println("Ce mois n'existe pas !")
    }
}

Tout d’abord, nous définissons une fonction générale, en lignes 1-19, qui retourne la position en fonction du mois passé en argument.

  • Une fonction se déclare avec le mot-clé fun.
  • Les arguments de cette fonction se déclarent entre parenthèses, mais avec la syntaxe NomVariable : typeVariable.
  • Le type de retour est déclaré après la liste des arguments et le signe deux-points.
  • Les types utilisés sont similaires à ceux du langage Java : Int pour un entier, String pour une chaîne de caractères.
  • Les points-virgules ne sont pas nécessaires en fin de ligne.
  • Tout comme en Java, les mots-clés if et throw s’utilisent simplement (ligne 17)
  • Une variable peut se déclarer à l’aide des syntaxes val nomVariable = expression ou var nomVariable = expression. Nous verrons plus tard la nuance entre les deux syntaxes.
  • mapOf<String, Int> permet de déclarer de manière aisée un dictionnaire ayant des clés de type String et des valeurs de type Int.
  • Nous pouvons ensuite voir que les mots-clés if, throw et return fonctionnent comme en Java. Nous verrons cela plus en détail ultérieurement.

Vient ensuite la fonction nécessaire dans toute application Kotlin version JVM: la fonction main.

  • Le paramètre args prend en compte les arguments passés au programme. Il est optionnel.
  • C’est l’attribut size, et non length, qui permet de connaître la taille du tableau.
  • Pour afficher un message à l’écran, on peut simplement écrire : println(messageAAfficher).
  • Il est possible de lever une exception de la même manière qu’en Java.
  • Nous pouvons utiliser l’interpolation de chaîne afin de construire simplement une chaîne de caractères (ligne 29). La syntaxe ${expression} permet d’insérer des valeurs à interpréter dans la chaîne.

III. Conclusions et remerciements

Dans cet article, nous avons eu un très rapide aperçu du langage Kotlin.

Dans la prochaine section, nous découvrirons les bases du langage.

Je remercie -FloT-Profil de -FloT- pour la relecture orthographique.

Je remercie également Mickael BaronProfil de Mickael Baron pour la relecture technique.

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 © 2020 Laurent Bernabe. Aucune reproduction, même partielle, ne peut être faite de ce site ni 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.