Contenu

• Kotlin vs Java, le dernier propose un code plus succinct - sans findViewByIds
• Kotlin est null safe par défaut
• Fonctions d'extension
• Coroutines sont des citoyens de première classe
• Il n'y a pas d'exceptions vérifiées
• Prise en charge native de la délégation
• Classes de données
• Cast intelligents
• Soutien aux constructeurs
• Pas de support pour les conversions d'élargissement implicites
• Bibliothèques de traitement d'annotations avec Kotlin
• Interchangeabilité avec Java
• Emballer

Java est peut-être le premier langage de programmation auquel on pense quand on pense à Android, mais vous ne devez pas avoir utiliser Java pour le développement Android. En fait, Kotlin est maintenant le moteur de recherche de Google.préférélangue officielle pour Android!

Pour en savoir plus sur Java, obtenez un cours d'introduction gratuit à Java dans Make Android Apps.

Aujourd'hui, Android Studio est livré avec la prise en charge de Kotlin intégrée. Créer un projet Android qui comprend le code Kotlin est aussi simple que de cocher une case dans l'assistant de création de projet d'Android Studio. Le nombre d’heures supplémentaires est devenu de plus en plus populaire, au point que cette décision est maintenant essentiellement une question de préférence.

Mais si vous passez de Java à Kotlin, que gagnez-vous exactement? Quelles sont les fonctionnalités de Kotlin, contrairement à Java, et inversement?

Dans cet article, nous allons examiner toutes les différences majeures entre Kotlin et Java.

Kotlin vs Java, le dernier propose un code plus succinct - sans findViewByIds

Si vous comparez une classe Kotlin et une classe Java qui effectuent le même travail, la classe Kotlin sera généralement beaucoup plus concise, mais il existe un domaine en particulier où Kotlin peut réduire considérablement la quantité de code passe-partout que vous devez écrire: findViewByIds.

Les extensions Kotlin Android vous permettent d’importer une référence à une vue dans votre fichier d’activité. Vous pourrez alors utiliser cette vue comme si elle faisait partie de l’activité. Le résultat? Vous ne devrez plus jamais écrire une autre méthode findViewById!

Avant de pouvoir utiliser ces extensions, vous devez ajouter un plugin supplémentaire à votre fichier build.gradle au niveau du module (apply plugin: 'kotlin-android-extensions'), mais vous êtes prêt à importer des vues pour la première fois. Par exemple, si votre fichier activity_main.xml contient un TextView avec l’ID textView, vous devez ajouter ce qui suit à votre activité:

importer kotlinx.android.synthetic.main.activity_main.textView

Vous pouvez ensuite accéder à ce TextView en utilisant uniquement son ID:

textView.setText ("Hello World")

C'est beaucoup plus succinct que l'équivalent Java:

TextView text = (TextView) findViewById (R.id.textView); text.setText ("Hello World");

Kotlin est null safe par défaut

Les exceptions NullPointerExceptions sont une énorme source de frustration pour les développeurs Java. Java vous permet d'attribuer la valeur null à n'importe quelle variable, mais si vous essayez d'utiliser une référence d'objet ayant une valeur null, préparez-vous à rencontrer une exception NullPointerException!

Lisez aussi: Introduction de Kotiln pour Android

Dans Kotlin, tous les types sont non nullables (impossible de conserver une valeur null) par défaut. Si vous essayez d’affecter ou de renvoyer null dans votre code Kotlin, il échouera au moment de la compilation et aucune des lignes suivantes ne compilera:

nom de la valeur: String = null

fun getName (): String = null

Si vous vraiment Si vous souhaitez affecter une valeur null à une variable de Kotlin, vous devez explicitement marquer cette variable comme nullable, en ajoutant un point d'interrogation après le type:

nombre val: Int? = null

Cela rend presque impossible la rencontre de NullPointerExceptions dans Kotlin. En fait, si vous rencontrez cette exception, il y a de fortes chances que vous ayez explicitement demandé à Kotlin d'en lancer une, ou que NullPointerException provient d'un code Java externe.

Fonctions d'extension

Kotlin donne aux développeurs la possibilité d’étendre une classe avec de nouvelles fonctionnalités, ce qui est idéal si vous estimez qu’il manque toujours une méthode importante à une classe!

Ces «fonctions d’extension» ne sont pas disponibles en Java, bien qu’elles soient disponibles dans d’autres langages de programmation que vous pouvez utiliser pour le développement Android, tels que C #.

Lire ensuite: Tutoriel Java pour les débutants

Pour créer une fonction d’extension, vous devez préfixer le nom de la classe que vous souhaitez étendre (telle que "String") au nom de la fonction que vous créez ("styleString"), par exemple:

fun String.styleString (): String {// Donnez un style à la chaîne, puis renvoyez-la //}

Vous pouvez ensuite appeler cette fonction sur des instances de la classe étendue, via le. notation, comme si elle faisait partie de cette classe:

myString.styleString ()

Coroutines sont des citoyens de première classe

À chaque fois que vous lancez une opération longue, telle qu'une opération d'E / S réseau ou une utilisation intensive du processeur, le thread appelant est bloqué jusqu'à la fin de l'opération. Étant donné qu'Android est mono-thread par défaut, dès que vous bloquez le thread principal, l'interface utilisateur de votre application va se figer et reste inactive jusqu'à la fin de l'opération.

En Java, la solution consistait généralement à créer un thread d'arrière-plan sur lequel vous pouvez effectuer ce travail intensif ou de longue durée, mais la gestion de plusieurs threads peut conduire à du code complexe, source d'erreurs, et la création d'un nouveau thread est une opération coûteuse.

Vous pouvez créer des threads supplémentaires dans Kotlin, mais vous pouvez également utiliser des coroutines. Coroutines effectue des tâches longues et intensives en suspendant l'exécution à un moment donné sans bloquer le thread, puis en reprenant cette fonction ultérieurement, éventuellement sur un autre thread. Cela vous permet de créer du code asynchrone non bloquant qui regards synchrone, et donc plus clair, concis et lisible par l'homme. Les Coroutines sont également sans pile, elles utilisent donc moins de mémoire que les threads et ouvrent la porte à des styles supplémentaires de programmation asynchrone non bloquante, telle que async / wait.

Il n'y a pas d'exceptions vérifiées

Kotlin n’a pas vérifié les exceptions, vous n’avez donc pas besoin d’attraper ou de déclarer des exceptions.

Que cela vous attire vers Kotlin ou que vous souhaitiez vous en tenir à Java dépendra de votre opinion sur les exceptions vérifiées, car il s'agit d'une fonctionnalité qui divise la communauté des développeurs. Si vous en avez marre des blocs try / catch qui encombrent votre code Java, vous serez satisfait de cette omission. Toutefois, si vous constatez que les exceptions cochées vous incitent à envisager la résolution des erreurs et vous poussent finalement à créer plus robuste. code, alors vous êtes plus susceptible de voir cela comme une zone où Java a l'avantage sur Kotlin.

Prise en charge native de la délégation

Contrairement à Java, Kotlin prend en charge le modèle de conception «composition sur héritage» via une délégation de première classe (parfois appelée délégation implicite). La délégation est l'endroit où un objet récepteur délègue des opérations à un deuxième objet délégué, qui est un objet d'assistance avec le contexte d'origine.

La délégation de classe de Kotlin est une alternative à l’héritage qui permet d’utiliser un héritage multiple. Dans l’intervalle, les propriétés déléguées de Kotlin permettent d’empêcher la duplication de code, par exemple si vous devez réutiliser le même code pour les getters et les setters de plusieurs propriétés, puis vous pouvez extraire ce code dans une propriété déléguée. La propriété delegate doit définir la fonction d'opérateur getValue et, éventuellement, l'opérateur setValue:

Classe Delegate {opérateur fun getValue (...) ... ... ...}} opérateur fun setValue (...) ... ... ...}}

Ensuite, lorsque vous créez une propriété, vous pouvez déclarer que les fonctions d’acquisition et de définition de cette propriété sont gérées par une autre classe:

class MyClass {propriété var: String by Delegate ()}

Classes de données

Il n’est pas rare qu’un projet ait plusieurs classes ne conservant que des données. En Java, vous vous retrouverez à écrire beaucoup de code standard pour ces classes, même si celles-ci ont très peu de fonctionnalités. En règle générale, vous devez définir un constructeur, des champs pour stocker les données, des fonctions d’obtention et de définition pour chaque champ, ainsi que des fonctions hashCode (), equals () et toString ().

En Kotlin, si vous incluez le mot-clé ‘data’ dans votre définition de classe, le compilateur effectuera tout ce travail pour vous, y compris la génération de tous les getters et setters nécessaires:

Classe de données Date (var month: String, var day: Int)

Cast intelligents

En Java, vous devez souvent vérifier le type, puis transtyper un objet dans des situations où il est déjà clair que cet objet peut être transtypé.

Les diffusions intelligentes de Kotlin peuvent gérer ces diffusions redondantes. Vous n'avez donc pas besoin de transtyper une déclaration si vous l'avez déjà vérifiée auprès de l'opérateur "est" de Kotlin. Par exemple, le compilateur sait que la distribution suivante est sûre:

if (hello is String) {printString (hello)}

Soutien aux constructeurs

Contrairement à Java, une classe Kotlin peut avoir un constructeur primaire et un ou plusieurs constructeurs secondaires, que vous créez en les incluant dans la déclaration de classe:

Classe constructeur MainActivity (firstName: String) {}

Pas de support pour les conversions d'élargissement implicites

Kotlin ne prend pas en charge les conversions avec élargissement implicite des nombres. Par conséquent, les types plus petits ne sont pas convertis implicitement en types plus grands. En Kotlin, si vous souhaitez affecter une valeur de type Byte à une variable Int, vous devez effectuer une conversion explicite, alors que Java prend en charge les conversions implicites.

Bibliothèques de traitement d'annotations avec Kotlin

Kotlin prend en charge tous les frameworks et bibliothèques Java existants, y compris les frameworks avancés qui reposent sur le traitement des annotations, bien que certaines bibliothèques Java fournissent déjà des extensions Kotlin, telles que RxKotlin.

Si vous souhaitez utiliser une bibliothèque Java reposant sur le traitement des annotations, son ajout à votre projet Kotlin est légèrement différent, car vous devrez spécifier la dépendance à l'aide de la commande. Kotlin-Kapt puis utilisez l’outil de traitement des annotations Kotlin (kapt) au lieu d’annotationProcessor. Par exemple:

// Applique le plugin // applique le plugin: kotlin-kapt // Ajoute les dépendances respectives à l'aide de la configuration de kapt // dependencies {kapt "com.google.dagger: compilateur dagger: $ dagger-version" ... ... ...}

Interchangeabilité avec Java

Lorsque vous discutez de l’utilisation de Kotlin ou de Java pour le développement Android, vous devez savoir qu’il existe une troisième option: utilise les deux. Malgré toutes les différences entre les deux langages, Java et Kotlin sont 100% interopérables. Vous pouvez appeler du code Kotlin à partir de Java et du code Java à partir de Kotlin. Il est donc possible d’avoir Kotlin et les classes Java côte à côte au sein du même projet, et tout sera compilé.

Cette flexibilité pour passer d’une langue à l’autre est utile lorsque vous débutez avec Kotlin, car elle vous permet d’introduire Kotlin dans un projet existant de manière incrémentielle, mais vous pouvez également préférer utiliser les deux langues de manière permanente. Par exemple, il est possible que vous préfériez écrire certaines fonctionnalités dans Kotlin et que vous trouviez certaines fonctionnalités plus faciles à écrire en Java. Étant donné que Kotlin et Java sont tous deux compilés en bytecode, vos utilisateurs finaux ne pourront pas dire où se termine votre code Java et le code Kotlin commence. Il n’ya donc aucune raison pour laquelle vous ne pouvez pas publier une application composée de Java. et Code Kotlin.

Si vous souhaitez essayer Kotlin par vous-même, tant que vous avez installé Android Studio 3.0 Preview ou une version ultérieure, vous pouvez commencer à utiliser:

• Créez un nouveau projet Android Studio. La méthode la plus simple consiste à créer un nouveau projet et à cocher la case "Inclure le support Kotlin" dans l’assistant de création de projet.

• Ajouter une classe Kotlin à un répertoire existant. Tout en maintenant la touche Contrôle enfoncée, cliquez sur le répertoire en question, puis sélectionnez ‘Fichier> Nouveau> Fichier / Classe Kotlin.’ Android Studio affiche une bannière vous demandant de configurer votre projet pour prendre en charge Kotlin. cliquez sur le lien "Configurer" et suivez les instructions à l'écran.

• Convertissez les fichiers Java existants en Kotlin. Vous pouvez exécuter n’importe quel fichier Java via un convertisseur Kotlin. Pour ce faire, cliquez sur le fichier en maintenant la touche Contrôle enfoncée, puis sélectionnez "Code> Convertir un fichier Java en fichier Kotlin".

Emballer

Comme vous pouvez le constater, il existe de nombreuses bonnes raisons de préférer Kotlin à Java, mais il existe quelques domaines dans lesquels Java domine. Peut-être plus particulièrement: de nombreux développeurs Android sont tout simplement plus familiarisés avec Java à ce stade. Il est probable que le débat entre Kotlin et Java ne s’installe pas de sitôt, les deux ayant leurs propres mérites. Alors, allez-vous passer à Kotlin, ou pensez-vous que Java est toujours la meilleure option pour le développement Android?

Lire ensuite: Une introduction à la syntaxe Java pour le développement Android