Introduction à Kotlin pour Android

Dans le monde Android, je suis sûr qu'il n'y a personne qui n'a pas entendu parler de Java. Un langage de programmation puissant qui peut créer des applications qui s'exécutent sur presque n'importe quel système d'exploitation sur n'importe quel matériel. Cependant, au fil des ans, un certain nombre de nouveaux langages de programmation ont été introduits pour s'exécuter également sur la machine virtuelle Java. Kotlin est l'un de ces langages, qui fait partie de ce que Google fait, pour rendre le développement d'applications Android « meilleur ». Google a annoncé son soutien généralisé à Kotlin lors de la Google I/O 2017.

Bien sûr, nous savons que Kotlin est destiné aux développeurs d'applications et qu'ils l'adorent ! Mais pourquoi l'aiment-ils ? Qu'est-ce qui fait que Google renforce à nouveau l'importance de Kotlin pour le développement d'applications en 2018 ? Qu'est-ce que c'est exactement ?

Langage de programmation à typage statique qui s'exécute sur JVM, Kotlin est un langage de programmation et de développement de JetBrains. Kotlin est un langage moderne, expressif, sûr et puissant qui peut être interopérable avec nos langages Android existants. Certaines autres fonctionnalités incluent :

1. Kotlin est entièrement pris en charge par Android Studio 3.0 et versions ultérieures.

2. Kotlin est un langage basé sur JVM créé par "JetBrains", l'équipe derrière "Intellij".

3. Intellij est la base d'Android Studio.

4. Kotlin est un "langage orienté objet"

Pourquoi Kotlin ?

Poids léger :

La bibliothèque Kotlin est assez petite par rapport aux autres. Ceci est important car les limites des méthodes Android impliquant Proguard et Multidexing sont toujours un problème à résoudre. Toutes ces solutions ajouteront des complexités qui peuvent prendre du temps lors du débogage. Kotlin ajoute moins de 7 000 méthodes.

Hautement interopérable :

Kotlin fonctionne bien avec les bibliothèques Java. L'équipe Kotlin souhaite continuer à développer les projets en cours qui sont écrits en Java sans avoir à réécrire tout le code. Kotlin est donc un langage extrêmement interopérable.

Intégré à Android Studio :

Kotlin est intégré à Android Studio et Gradle. Il est facile d'installer Kotlin car il nécessite un plugin pour l'IDE et un pour Gradle. Il ne sera pas difficile de démarrer un projet Android en utilisant Kotlin.

Plus d'exceptions NullPointer :

NullPointerException est l'une des causes les plus courantes de plantage d'applications dans Android. Pour corriger cette exception et protéger votre code, l'utilisation de la vérification nulle à chaque fois est une tâche fastidieuse. Mais dans Kotlin, il s'agit d'une exception car la sécurité nulle est déjà intégrée.

Performance :

L'application Kotlin s'exécute aussi vite qu'elle le ferait sur Java. Avec la prise en charge de Kotlin pour les fonctions en ligne, en utilisant « lambda », les applications s'exécutent souvent encore plus rapidement.

Dans Android Studio 3.0, vous pouvez choisir de créer l'activité dans Kotlin. Le moyen le plus simple de commencer à utiliser kotlin est de convertir automatiquement Java en Kotlin. Vous pouvez écrire en Java, puis copier-coller le code Java dans le fichier kotlin et il suggérera la conversion.

Une autre méthode simple pour convertir un fichier Java en Kotlin :

Menu Android Studio >> Code >> Convertir le fichier Java en fichier Kotlin

La conversion sera de ce type :

Java:

public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity); } }

Kotlin :

class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity) } }

Après avoir configuré Kotlin, mettez à jour le fichier build.gradle pour l'application et implémentez les éléments ci-dessous :

Enfin, synchronisez le projet. Vous pouvez cliquer sur "Synchroniser maintenant". Cela fonctionne exactement de la même manière qu'en Java. Vous pouvez créer une version de l'application et la signer de la même manière que nous le faisons pour une application Android en Java.

Enfin, le compilateur Kotlin produit un « byte-code », sans aucune différence en termes d'apparence et de convivialité de l'application sous Android.

Maintenant, laissez-nous en savoir un peu plus sur la syntaxe Kotlin

• Définition du paquet :

  package com.example Import java.util.*

• Définition des variables :

  Int: Val a: Int = 3 // Immediate assignment Val b = 2 // “Int” type is Inferred Val c : Int // Type Required when no initializer is provided C = 3 // Deferred assignment

• Chaîne de caractères:

val firstName: String = "Raj" val lastName = "xyz" // still compile val dateOfBirth = "24th April, 1990" dateOfBirth = "28th July, 2000" // cannot be changed var car = "Toyota Matrix" car = "Mercedes-Maybach" // can be changed

Différence entre "Val" et "Var"

Val : Est un mot-clé que le premier est immuable ou en lecture seule (sa valeur ne peut pas être modifiée)

Var : est un mot-clé dont le type est déduit par le compilateur, l'affectation d'une autre valeur d'un type différent ne fonctionnera pas. En d'autres termes, la valeur de la variable peut changer, mais pas son type.

var age = 12 age = "12 years old" // Error: type mismatch val carName: String carName = "BMW Car" // will compile val carName = "Toyota", streetName = "Church street" // this won't compile // this will compile var carName = "Audi" var streetName = "Church street"

Exemples:

fun main(args: Array<String>) { val i = 10 println("i = $i") // prints "i = 10" } val accountBalance = 200 val bankMessage = "Your account balance is $accountBalance" // Your account balance is 200

Nous faisons référence à une variable par l'utilisation d'un caractère $ devant le nom de la variable. Notez que si la variable n'est pas correcte ou n'existe pas, le code ne sera pas compilé. Vous pouvez appeler des méthodes à partir d'une chaîne interpolée directement ; vous devez ajouter des accolades ${} pour l'envelopper.

val name = "Raj" val message = "The first letter in my name is ${name.first()}" // The first letter in my name is R

Définition des fonctions :

fun sum(a: Int, b: Int): Int { return a + b } fun main(args: Array<String>) { print("sum of 2 and 8 is ") println(sum(2, 8)) } // sum of 2 and 8 is 10

Fonction avec un corps d'expression et un type de retour inféré :

fun sum(a: Int, b: Int) = a + b fun main(args: Array<String>) { println("sum of 18 and 24 is ${sum(18, 24)}") } // sum of 18 and 24 is 42

Pour la boucle :

fun main(args: Array<String>) { val items = listOf("apple", "banana", "Mango") for (item in items) { println(item) } } // apple banana Mango

Utilisation des collections :

Iterating over a collection: fun main(args: Array<String>) { val items = listOf("apple", "banana", "mango") for (item in items) { println(item) } } Checking if a collection contains an object using “in” operator: fun main(args: Array<String>) { val items = setOf("apple", "banana", "mango") when { "orange" in items -> println("juicy") "apple" in items -> println("apple is fine") } } // apple is fine

Comment créer une instance de classe :

val customer = Customer() // No New Keyword

Constructeurs :

Une classe dans Kotlin peut avoir un constructeur principal et un ou plusieurs constructeurs secondaires. Le constructeur principal fait partie de l'en-tête de classe : il va après le nom de la classe

class Person constructor(firstName: String) { }

Déclarer des propriétés :

La classe Kotlin a des propriétés. Ceux-ci peuvent être déclarés comme mutables, en utilisant le mot-clé "var" ou en lecture seule en utilisant le mot-clé "val".

Par exemple :

class Address { var name: String = “” var street: String = “” var city: String = “” }

Interface :

Les interfaces dans Kotlin sont très similaires à Java 8. Elles peuvent contenir des déclarations de méthodes abstraites, ainsi que des implémentations de méthodes.

Une interface est définie à l'aide du mot clé interface

interface MyInterface { fun bar() fun foo() { // optional body } }

Implémentation d'interfaces :

class Child : MyInterface { override fun bar() { // body } }

Une classe ou un objet peut implémenter une ou plusieurs interfaces.