Qu'est-ce que Kotlin? L'alternative Java expliquée

Kotlin est un langage de programmation «pragmatique» à usage général, gratuit, open source, à typage statique, initialement conçu pour la JVM (Java Virtual Machine) et Android, qui combine des fonctionnalités de programmation orientées objet et fonctionnelles. Il est axé sur l'interopérabilité, la sécurité, la clarté et le support d'outillage. Des versions de Kotlin ciblant JavaScript ES5.1 et du code natif (utilisant LLVM) pour un certain nombre de processeurs sont également en production.

Kotlin est né chez JetBrains, la société derrière IntelliJ IDEA, en 2010, et est open source depuis 2012. L'équipe Kotlin compte actuellement plus de 90 membres à plein temps de JetBrains, et le projet Kotlin sur GitHub compte plus de 300 contributeurs. JetBrains utilise Kotlin dans plusieurs de ses produits, y compris son produit phare IntelliJ IDEA.

Kotlin comme langage Java plus concis

À première vue, Kotlin ressemble à une version plus concise et rationalisée de Java. Considérez la capture d'écran ci-dessus, où j'ai converti automatiquement un échantillon de code Java (à gauche) en Kotlin. Notez que la répétition stupide inhérente à l'instanciation des variables Java a disparu. L'idiome Java

StringBuilder sb = nouveau StringBuilder ();

Devient à Kotlin

val sb = StringBuilder ()

Vous pouvez voir que les fonctions sont définies avec le funmot - clé et que les points-virgules sont désormais facultatifs lorsque des retours à la ligne sont présents. Le valmot clé déclare une propriété en lecture seule ou une variable locale. De même, le varmot clé déclare une propriété mutable ou une variable locale.

Néanmoins, Kotlin est fortement typé. Les mots clés valet varne peuvent être utilisés que lorsque le type peut être déduit. Sinon, vous devez déclarer le type. L'inférence de type semble s'améliorer avec chaque version de Kotlin.

Jetez un œil à la déclaration de fonction en haut des deux volets. Le type de retour en Java précède le prototype, mais en Kotlin il succède au prototype, délimité par un deux-points comme en Pascal.

Ce n'est pas tout à fait évident dans cet exemple, mais Kotlin a assoupli l'exigence de Java selon laquelle les fonctions doivent être des membres de classe. Dans Kotlin, les fonctions peuvent être déclarées au niveau supérieur dans un fichier, localement dans d'autres fonctions, en tant que fonction membre à l'intérieur d'une classe ou d'un objet, et en tant que fonction d'extension. Les fonctions d'extension fournissent la capacité de type C # d'étendre une classe avec de nouvelles fonctionnalités sans avoir à hériter de la classe ou à utiliser un type de modèle de conception tel que Decorator.

Pour les fans de Groovy, Kotlin implémente des constructeurs; en fait, les constructeurs Kotlin peuvent être vérifiés. Kotlin prend en charge les propriétés déléguées, qui peuvent être utilisées pour implémenter des propriétés différées, des propriétés observables, des propriétés opposables et des propriétés mappées.

De nombreux mécanismes asynchrones disponibles dans d'autres langages peuvent être implémentés sous forme de bibliothèques à l'aide de coroutines Kotlin. Cela inclut async/ à awaitpartir de C # et ECMAScript, des canaux et une sélection de Go, et generators/ yieldde C # et Python.

Programmation fonctionnelle dans Kotlin

Autoriser les fonctions de haut niveau n'est que le début de l'histoire de la programmation fonctionnelle pour Kotlin. Le langage prend également en charge les fonctions d'ordre supérieur, les fonctions anonymes, les lambdas, les fonctions en ligne, les fermetures, la récursivité de queue et les génériques. En d'autres termes, Kotlin possède toutes les caractéristiques et avantages d'un langage fonctionnel. Par exemple, considérons les idiomes fonctionnels de Kotlin suivants.

Filtrer une liste dans Kotlin

val positifs = list.filter {x -> x> 0}

Pour une expression encore plus courte, utilisez itquand il n'y a qu'un seul paramètre dans la fonction lambda:

val positifs = list.filter {it> 0}

Traverser une carte / liste de paires à Kotlin

for ((k, v) in map) {println ("$ k -> $ v")}

ket  v peut être appelé n'importe quoi.

Utilisation de plages dans Kotlin

for (i in  1..100) {...} // plage fermée: inclut 100

for (i in  1 jusqu'à 100) {...} // plage semi-ouverte: n'inclut pas 100

for (x in  2..10 step 2) {...}

pour (x dans  10 downTo 1) {...}

if (x en  1..10) {...}

Les exemples ci-dessus montrent le for mot -  clé ainsi que l'utilisation de plages.

Même si Kotlin est un langage de programmation fonctionnel à part entière, il préserve la plupart de la nature orientée objet de Java en tant que style de programmation alternatif, ce qui est très pratique lors de la conversion de code Java existant. Kotlin a des classes avec des constructeurs, ainsi que des classes internes imbriquées, internes et anonymes, et il a des interfaces comme Java 8. Kotlin n'a pas denew mot - clé. Pour créer une instance de classe, appelez le constructeur comme une fonction normale. Nous l'avons vu dans la capture d'écran ci-dessus.

Kotlin a un héritage unique d'une superclasse nommée, et toutes les classes Kotlin ont une superclasse par défaut Any, qui n'est pas la même que la classe de base Java java.lang.Object. Anyne contient que trois fonctions membres prédéfinies: equals(), hashCode(), et toString().

Les classes Kotlin doivent être marquées avec le openmot - clé afin de permettre à d'autres classes d'en hériter; Les classes Java sont un peu le contraire, car elles peuvent être héritées à moins d'être marquées avec le finalmot - clé. Pour remplacer une méthode de superclasse, la méthode elle-même doit être marquée openet la méthode de sous-classe doit être marquée override. Tout cela fait partie de la philosophie de Kotlin de rendre les choses explicites plutôt que de se fier aux défauts. Dans ce cas particulier, je peux voir où la manière de Kotlin de marquer explicitement les membres de classe de base comme ouverts à l'héritage et les membres de classe dérivés comme remplacements évite plusieurs types d'erreurs Java courantes.

Dispositifs de sécurité dans Kotlin

Parlant d'éviter les erreurs courantes, Kotlin a été conçu pour éliminer le danger des références de pointeur nulles et rationaliser la gestion des valeurs nulles. Pour ce faire, il rend nullillégal pour les types standard, ajoute des types Nullable et implémente des notations de raccourci pour gérer les tests NULL.

Par exemple, une variable régulière de type  ne peut pas contenir  :String null

var a: String = "abc"

a = null // erreur de compilation

Si vous devez autoriser les valeurs nulles, par exemple pour contenir les résultats d'une requête SQL, vous pouvez déclarer un type Nullable en ajoutant un point d'interrogation au type, par exemple String?.

var  b: Chaîne?

b = nul  // ok

Les protections vont un peu plus loin. Vous pouvez utiliser un type non Nullable en toute impunité, mais vous devez tester un type Nullable pour les valeurs Null avant de l'utiliser.

Pour éviter la grammaire verbeuse normalement nécessaire pour les tests nuls, Kotlin introduit un appel sûr , écrit ?.. Par exemple, renvoie si n'est pas , et sinon. Le type de cette expression est .b?.length b.lengthbnullnullInt?

En d'autres termes, b?.lengthest un raccourci pour if (b != null) b.length else null. Cette syntaxe s'enchaîne bien, éliminant beaucoup de logique prolixe, en particulier lorsqu'un objet a été rempli à partir d'une série de requêtes de base de données, dont l'une peut avoir échoué. Par exemple, bob?.department?.head?.namerenvoie le nom du chef de département de Bob si Bob, le département et le chef de département sont tous non nuls.

Pour effectuer une certaine opération uniquement pour les valeurs non nulles, vous pouvez utiliser l'opérateur d'appel sécurisé ?.avec  let:

val listWithNulls: List = listOf ("A", null)

for (élément dans listWithNulls) {

      item? .let {println (it)} // affiche A et ignore null}

Souvent, vous souhaitez renvoyer une valeur valide mais spéciale à partir d'une expression Nullable, généralement pour pouvoir l'enregistrer dans un type non Nullable. Il y a une syntaxe spéciale pour cela appelée l'opérateur Elvis (je ne plaisante pas), écrite ?:.

val l = b? .longueur?: -1

est l'équivalent de 

val l: Int = if (b! = null) b.length else -1

Dans la même veine, Kotlin omet les exceptions vérifiées de Java, qui sont des conditions jetables qui doivent être interceptées. Par exemple, la signature JDK

Appendable append (CharSequence csq) lève  IOException;

vous oblige à attraper IOExceptionchaque fois que vous appelez une appendméthode:

essayez {

  log.append (message)

}

catch (IOException e) {

  // Faites quelque chose avec l'exception

}

Les concepteurs de Java ont pensé que c'était une bonne idée, et c'était une nette victoire pour les programmes jouets, tant que les programmeurs implémentaient quelque chose de sensé dans la catchclause. Trop souvent dans les grands programmes Java, cependant, vous voyez le code dans lequel l'obligatoire catchclause contient rien , mais un commentaire: //todo: handle this. Cela n'aide personne et les exceptions vérifiées se sont avérées être une perte nette pour les grands programmes.

Coroutines Kotlin

Les coroutines de Kotlin sont essentiellement des threads légers. Vous les démarrez avec le launchconstructeur de coroutine dans le contexte de certains CoroutineScope. L'une des portées de coroutine les plus utiles est runBlocking{}, qui s'applique à la portée de son bloc de code.

import kotlinx.coroutines. *

fun main () = runBlocking {// ceci: CoroutineScope

    launch {// lance une nouvelle coroutine dans le cadre de runBlocking

        delay (1000L) // délai non bloquant pendant 1 seconde

        println ("Monde!")

    }

    println ("Bonjour")

}

Ce code produit la sortie suivante, avec un délai d'une seconde entre les lignes:

Bonjour,

Monde!

Kotlin pour Android

Jusqu'en mai 2017, les seuls langages de programmation officiellement pris en charge pour Android étaient Java et C ++. Google a annoncé la prise en charge officielle de Kotlin sur Android lors de Google I / O 2017, et à partir d'Android Studio 3.0, Kotlin est intégré à l'ensemble d'outils de développement Android. Kotlin peut être ajouté aux versions antérieures d'Android Studio avec un plug-in.

Kotlin compile avec le même code d'octet que Java, interagit avec les classes Java de manière naturelle et partage ses outils avec Java. Parce qu'il n'y a pas de frais généraux pour les appels entre Kotlin et Java, l'ajout de Kotlin de manière incrémentielle à une application Android actuellement en Java est parfaitement logique. Les quelques cas où l'interopérabilité entre Kotlin et le code Java manque de grâce, tels que les propriétés Java définies uniquement, sont rarement rencontrés et facilement corrigés.

Pinterest était l'enfant de l'affiche pour les applications Android écrites en Kotlin dès novembre 2016, et il a été mentionné en bonne place lors de Google I / O 2017 dans le cadre de l'annonce de Kotlin. De plus, l'équipe Kotlin aime citer les applications Evernote, Trello, Square et Coursera pour Android.

Kotlin contre Java

La question de savoir s'il faut choisir Kotlin ou Java pour un nouveau développement a beaucoup été soulevée dans la communauté Android depuis l'annonce de Google I / O, bien que les gens se posaient déjà la question en février 2016 lorsque Kotlin 1.0 a été livré. La réponse courte est que le code Kotlin est plus sûr et plus concis que le code Java, et que les fichiers Kotlin et Java peuvent coexister dans les applications Android, de sorte que Kotlin n'est pas seulement utile pour les nouvelles applications, mais aussi pour développer les applications Java existantes.

Le seul argument convaincant que j'ai vu pour choisir Java plutôt que Kotlin serait le cas des débutants complets du développement Android. Pour eux, il pourrait y avoir un obstacle à surmonter étant donné que, historiquement, la plupart de la documentation et des exemples Android sont en Java. D'un autre côté, la conversion de Java en Kotlin dans Android Studio consiste simplement à coller le code Java dans un fichier Kotlin.

Pour presque tous ceux qui font du développement Android, les avantages de Kotlin sont convaincants. Le temps typique cité pour un développeur Java pour apprendre Kotlin est de quelques heures - un petit prix à payer pour éliminer les erreurs de référence nulles, activer les fonctions d'extension, prendre en charge la programmation fonctionnelle et ajouter des coroutines. L'estimation approximative typique indique une réduction d'environ 40% du nombre de lignes de code de Java à Kotlin.