Kotlin

Un langage issu de Java, open source, interopérable.

On estime qu’au fil des années, Java va se perdre au profit de Kotlin. En sachant qu’un projet Kotlin peut contenir des fichiers à la fois de Java et de Kotlin, la migration est en cours.

En 2018, Google le considère comme une langage officiel, ce qui enclenche sa popularisation.

Utilisations : mobile cross-platform, code natif pour Mac et Windows, Data Science, développement back end (Java EE), JavaScript, Android

Les fondamentaux

Main

A l’image de Java, toute opération doit être contenue dans la fonction Main pour être exécutée.

var phrase = "hello world !"
fun main(args: Array<String>) {
	println("Plus besoin du System.out.println, mais surtout : $phrase")
}

On remarque :

• une fonction est déclarée avec fun

• les points virgules ne sont pas nécessaires (voire même obsolètes)

• les paramètres d’une fonction sont déclarés avec args: type

• une variable est déclarée avec var

• il est possible de déclarer une variable en dehors d’une fonction ou d’une classe

• Kotlin fait de l’inférence de type : le type est déterminé dynamiquement

• Kotlin fait de la String interpolation : il est possible de mettre une variable dans une chaine de caractères

Types

En Kotlin, “tout est objet” : les types commencent donc tous par une majuscule.

Types de variables : Byte, Short, Int, Long, Float, Double, Char, Boolean, String, Array (pas de tableau avec les crochets).

A noter : toutes les Strings sont itérables.

Variables

Une variable peut être déclarée de différentes façons :

• var pour une variable dont la valeur est modifiable

• val pour une variable dont la valeur est attribuée au moment du runtime et qui ne peut plus être modifiée ensuite

• const var pour une variable dont la valeur est attribuée à la compilation et qui ne peut plus être modifiée ensuite

Afin de différer l’affectation d’une variable, on utilise la propriété déléguée by avec lazy : l’affectation ne sera faite qu’au moment où la lecture de cette variable est demandée. Concrètement, le bout de code (appelé lambda) sera exécuté et la valeur résultante sera utilisée.

fun main(args: Array<String>) {
	var mot = "nope."
	val info: String by lazy { "Le mot magique est $mot." }
  mot = "merciiiii"
	println(info) //Le mot magique est merciiiii.
}

Par défaut, un objet ne peut pas être nul : null safety.

Il est possible de rendre un objet nullable en le précisant au moment de la déclaration avec Type?. Dans ce cas, il faudra tester la nullité à chaque utilisation de la variable avec l’opérateur ?..

var prenom: String?
var nbCaracteres: Int? = prenom?.length
//on obtient la longueur de la variable prenom 
//  ou "null" si la variable prenom est nulle

A noter :

• il n’y a pas d’opérateur ternaire mais certains équivalents (vus plus loin)

• un intervalle (range) peut être défini avec .. (ou downTo en décroissant)

Structures de contrôle

Exemples issus de la documentation Kotlin.

• if

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

// equivaut a l'expression
fun maxOf(a: Int, b: Int) = if (a > b) a else b

• when

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long" //check du type
        !is String -> "Not a string"
        else       -> "Unknown"
    }

// avec in
when {
    "orange" in items -> println("juicy")
    "apple" in items -> println("apple is fine too")
}

A noter : super switch (il break dès qu’il trouve)

• for

val items = listOf("apple", "banana", "kiwifruit")
for (item in items) {
    println(item)
}

// possible d'appeler l'indice
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

// possible d'appeler cle/valeur
for ((key,value) in items.withIndex()) {
	println("index at $index is $value")
}

• while (et do while)

val items = listOf("apple", "banana", "kiwifruit")
var index = 0
while (index < items.size) {
    println("item at $index is ${items[index]}")
    index++
}

Conversions de type

La conversion est implicite et comme les types sont des objets, on peut utiliser des fonctions de conversion (ex : unEntier.toLong()).

Les fonctions

Une fonction est définie avec fun.

On spécifie les paramètres avec leur nom, leur type et éventuellement une valeur par défaut : (x:Int=0).

On spécifie le type de la valeur retournée après les deux-points : String, qui peut être vide Unit (void en Java).

fun afficherBonjour() : Unit {
	println("Bien le bonjour")
}

fun additionner(x:Int=0, y:Int=0) : Int {
	return x+y
}

Single-expression functions :

Si la fonction ne retourne qu’une expression simple, il est possible de raccourcir l’écriture avec un = qui remplace les accolades :

fun afficherBonjour() = println("Bien le bonjour")

fun additionner(x:Int=0, y:Int=0) = return x+y

vararg :

Il est possible de passer n paramètres à une variable vararg pour un même type défini ou même générique.

fun multiplier(vararg nombre: Float): Float {
    var res = 1.0f
    for (item in nombre) {
        res *= item
    }
    return res
}
println(multiplier(4.0f, 2.0f, 3.0f)) //24.0
println(multiplier(6.7f, 2.5f)) //16.75

Fonctions génériques :

Une fonction peut prendre un paramètre générique indiqué avec la notation diamant : fun <T>.

fun <T> creerUneListe(vararg valeurs:T): List<T> {
	var liste = ArrayList<T>()
	for(item in valeurs) {
		liste.add(item)
	}
	return liste
}
println(creerUneListe("vinaigre", "beurre", "chaussettes")) //[vinaigre, beurre, chaussettes]
println(creerUneListe(18, 96.3, "blop")) //[18, 96.3, blop]

Extensions

On peut étendre une classe ou interface avec une nouvelle fonctionnalité sans avoir à en hériter, grâce aux extensions : fun Class.fonctionDExtension(params) { … }.

Par exemple, pour ajouter une fonction d’extension à la classe Date pour afficher la date et l’heure :

import java.util.Date;

fun Date.afficherHm() =
	println("${this.hours}h${this.minutes}")

fun main() {
	Date().afficherHm()
}

A noter : this réfère à l’instance

Opérateur Elvis

L’opérateur Elvis ?: est utilisé pour retourner une valeur même si l’expression est nulle.

var unMot: String? = null
val tailleMot = unMot?.length?:-1
println("La longueur du mot est $tailleMot")
//La longueur du mot est -1

Collections

Une collection est un groupe d’éléments de nombre variable.

Les principales collections de Kotlin sont List, Set et Map.

Lambdas

Grossièrement, une expression lambda est une fonction non déclarée, passée directement en paramètre à une fonction entre accolades : { expression }.

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.uppercase() }
    .forEach { println(it) }

A noter : it fait référence à l’élément en train d’être testé

Une fonction anonyme (sans nom) est une alternative qui permet de spécifier le type de retour, elle peut également être placée en paramètre d’une fonction : fun(param):Type = expression.

exemple.filter(fun(item) = item > 0)

Try / Catch

Classique.

var aTester: Int = try {
	// expression
} catch (e: Exception) {
	throw Exception(e)
}

Les classes

Une classe est définie avec class et éventuellement d’autres mots-clés.

Une simple class aura un constructeur, les getter/setter pour chaque attribut, sauf un attribut val qui n’est pas modifiable donc n’aura pas de setter.

Une data class aura, en plus, les méthodes toString(), equals(), hashcode() et copy().

data class Personne(
		val id: Int,
		val nom: String,
		val prenom: String,
		val dateDeNaissance: Date? = null
)

Une classe abstraite est déclarée avec abstract class.

Une instance est crée sans le new de Java, simplement en appelant la classe et en renseignant les paramètres éventuels : var bob = Personne(1, "Dylan", "Bob", 24/05/1941).

Héritage

Par défaut, toutes les classes sont final et donc fermées à l’héritage.

On rend une classe ouverte à l’héritage avec open : open data class MaClasseMere(...).

Pour qu’une méthode de cette classe soit ouverte à la surcharge (override), elle doit être open également.

Une classe qui hérite d’une autre est déclarée avec les deux-points : (extends) : class MaClasseFille (...) : MaClasseMere. Les méthodes surchargées sont déclarées avec override.

open class UneClasseMere {
	open fun uneMethodeSurchargeable...
	fun uneMethodeNonSurchargeable...
}

class UneClasseFille : UneClasseMere {
	override fun uneMethodeSurchargeable...
	fun uneMethodeDeFille....
}

Champ et propriété

Les getter/setter peuvent être définis manuellement.

var stringRepresentation: String
    get() = this.toString()
    set(value) {
        setDataFromString(value) // parses the string and assigns values to other properties
    }

Interface

“Contrat”.

Une interface est déclarée avec interface.

Une classe qui implémente une interface est également déclarée avec les deux-points : (implements). Les méthodes surchargées sont déclarées avec override.

interface UneInterface {
	val UneConstante
	fun uneMethode
	fun uneAutreMethode
}

class UneClasse : UneInterface {
	override val UneConstante = "une valeur"
	override fun uneMethode...
	override fun uneAutreMethode...
}

Classe Enum

Liste de constantes de même type.

Une énumération est déclarée avec enum class.

Chaque constante est un objet qui peut être initialisé.

enum class JourOuvre {
	LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI
}

Classe Objet

Un singleton peut être créé avec une classe objet (ou companion object) déclarée avec object (tout ce qu’il y a dedans est static).

object DAOFactory {
	fun getDao(type: DAOType) =
	when(type) {
            DAOType.MEMORY-> ArticleDAOMemoryImpl()
//            DAOType.INTERNET -> ArticleDAOMemoryImpl()
//            DAOType.DB -> ArticleDAOMemoryImpl()
		}
}