Introduction à Kotlin

Introduction à Kotlin

Google a officialisé récemment Kotlin en tant que langage supporté par Android,
il est temps de faire un tour du coté de ce language !

Mise en place

Le plugin Kotlin plugin est embarqué dans Android Studio depuis sa version 3.0. Si vous êtes dans une version antérieur, vous devrez l’installer.
Aller dans File | Settings | Plugins | Install JetBrains plugin… puis cherchez et installer le plugin Kotlin. Puis redémarrez votre IDE.

Dans votre projet Android (java), appellez l’action Convert Java File to Kotlin File
Pour cela, faites Cmd+Shift+A et tappez le nom de l’action. (Vous pouvez aussi passer par Code | Convert Java File to Kotlin File).

Découverte

Les fichiers utilisés en Kotlin seront suffixé en .kt au lieu de .java

Classes

Les classes en kotlin se définissent aussi avec « class », mais cette fois ci elles seront par défaut publiques

class Person {
 
}

Vous pouvez même définir plusieurs classes par fichier

class Person {
 
}
class Cat {
}

Pour définir des propriétés à notre class, c’est assez similaire à java

class Person {
    var name: String = ""
    var age: Int = 0
}

Comme vous pouvez le voir, la syntaxe est relativement différente de celle de java. Pour créer une variable en Kotlin, vous devez utiliser le mot var. Cependant, si vous voulez que votre variable soit en lecture seule (assigné une seule fois), utilisez le mot val.

Pour les question de sécurité autour de NullPointer, Kotlin fait aussi la distinction entre les variable pouvant être null et celles qui ne le seront jamais. Dans notre précédent exemple, nos variables name et age ne pourront jamais être null. Si on les assigne à la valeur null, le compilateur levera une erreur compiler .

Pour créer un variable pouvant être null, vous devrez ajouter un ? après le type de la variable. Par exemple:

var login: String? = null

Maintenant que nous avons notre class, créer une instance de Person se fait de la façon suivante :

var florent = Person()

Et non, pas de new en Kotlin.
Une fois notre instance créée, vous avez accès aux propriétés de la même façon que Java :

florent.name = "Florent"
florent.age = 26
florent.login = "Florent37"

Constructeurs

La syntaxe en Kotlin’s permettant de créer un constructeur est assez compacte :

class Person(var name: String, var age: Int, var login: String?) {
 
}

On met juste nos paramètres après le nom de la classe, entre nos parenthèses.

En fait, si vous n’avez pas besoin d’autres propriétés dans votre class, vous n’avez même pas besoin des acollades. Le code suivant suffit :

class Person(var name: String, var age: Int, var login: String?)

La construction se fera donc :

var florent = Person(« Florent », 26, « Florent37 »)

Vous pouvez ajouter d’autres constructeurs en plus de celui-ci,
pour cela, ajoutez une méthode nommée constructor

class Person(var name: String, var age: Int, var login: String?) {
     
    var email: String = ""
 
    constructor(name:String, age:Int, login: String?, email: String) : this(name, age, login) {
        this.email = email
    }
}

Ajouter des méthodes

En Kotlin, les fonctions sont déclarées avec le mot clé fun. Ajoutons une méthode à notre Person pour savoir si il est en age de voter :

fun isEligibleToVote(): Boolean {
    // If age is greater or equal to 18
    // return true
 
    return age >= 18
}

Vous noterez que le type de retour est indiqué à la fin de l’entête de fonction.

Vous pourrez appeller cette fonction de la même façon qu’en java:

jake.isEligibleToVote()

Et oui, autre petit tip, le ; est en option dans ce language 😉

Extensions !

Kotlin vous permet d’étendre une classe existante en lui ajoutant des méthodes, sans devoir l’étendre.
Ces fonctions sont appelées extensions.
Le nom de ces fonctions est prévixé par le nom de la class à étendre.

Par exemple, pour ajouter une méthode d’éxtension à notre objet Person, en le plaçant en dehors de cette classe, par exemple dans un autre fichier :

fun Person.isTeenager(): Boolean {
 
    // If age falls in the range
    // 13-19 return true
 
    return age in 13..19
}

On pourra directement utiliser la méthode

florent.isTeenager()

Les extensions s’avèrent très pratique en Android, nous pouvons par exemple ajouter une méthode aux TextView, aux Activity, aux Fragments, ou même aux Strings, par exemple

fun String.containsSpaces(): Boolean {
    return this.indexOf(" ")!=-1
}

Extends

Par défaut, les classes Kotlin sont déclarées finale, c’est à dire qu’il nous est impossible de les étendre.
Pour se faire, il vous faudra utiliser le mot clé open lors de leur définition :

open class Person(var name: String, var age: Int, var login: String?) {
    ...
}
 
class Employee(name: String, age: Int, login: String?, var company: String) : Person(name, age, login) {
     
}

Vous utiliserez ici les : au lieu du mot extends 😉

Créer une méthode simple

Pour créer une fonction qui va juste retourner une valeur, ou le résultat d’un expressio, vous pouvez utiliser l’opérateur = à la fin de la définition :

fun isOctogenarian(): Boolean = age in 80 .. 89

Méthodes lambdas

Une lambda ici est une méthode sans nom, elle sera juste définie en fonction de ses paramètres d’entrée, et son type de retour.

La syntaxe sera la suivante :

{x, y -> x + y}

C’est une simple lambda qui prend deux paramètres, x et y, et retourne leur somme.
Comme vous pouvez le deviner, les paramètres sont listés avant le -> et le corps de la méthode par la suite.
Les lambdas peuvent être assignées à des variables comme ceci :

val sumLambda: (Int, Int) -> Int = {x,y -> x + y}
val actualSum = sumLambda(3,4)

Notez que le type de la variable stockant la lambda spécifie les types des paramètres de celle-ci, ainsi que son type de retour.

Créer une méthode qui prend en entrée une lambda comme nous l’avons écrit est simple, elle peux être ajoutée en tant que paramètre comme une variable normale. Par exemple :

fun doubleTheResult(x:Int, y:Int, f:(Int, Int)->Int): Int {
    return f(x,y) * 2
}

On pourra appeler cette méthode :

val result1 = doubleTheResult(3, 4, sumLambda)

Mieux, on peux écrire la lambda directement !

val result2 = doubleTheResult(3, 4, {x,y -> x+y})

Les lambdas sont souvent utilisées sur des Arrays, par exemple sur ce tableau d’entiers :

val numbers:Array<Int> = arrayOf(1, 2, 3, 4, 5)

Si on veux mettre au carré chaque entrée du tableau, on va utiliser la méthode .map avec une lambda :

val squaredNumbers = numbers.map({x -> x * x})
 
// le tableau contiendra
// 1, 4, 9, 16, 25

Conditions

Les conditions if se font comme en Java,
Mais nous avons accès à un nouvel opérateur de conditions beaucoup plus puissant, le when !

val age = 17
 
val typeOfPerson = when(age){
     0 -> "New born"
     in 1..12 -> "Child"
     in 13..19 -> "Teenager"
     else -> "Adult"
}
 
// typeOfPerson est alors égal à "Teenager"

Boucles

Pour les boucles, on pourra utiliser un foreach, ici avec for(element in ARRAY)

val names = arrayOf("Jake", "Jill", "Ashley", "Bill")
 
for (name in names) {
    println(name)
}

On peux aussi le faire sur une rangée de valeurs

for (i in 0..9) {
    println(i)
}

String Templates

Kotlin vous permet d’insérer directement des variables ou expressions dans vos Strings, en les entourant d’accolades puis préfixés par un $ :

val name = "Bob"
println("My name is ${name}") // Prints "My name is Bob"
 
val a = 10
val b = 20
println("The sum is ${a+b}") // Prints "The sum is 30"

Conclusion

Dans ce tutoriel, vous avez appris les bases du langage Kotlin, mais cela va beacoup plus loin que ce que nous avons vu ici !