Tutoriel sur le langage Kotlin

Dès lors qu’une classe doit disposer d’un unique constructeur (nous verrons le cas de constructeurs multiples dans la section suivante), il faut respecter la syntaxe du constructeur primaire.

class Personne(nom: String) {
    val nom: String
    var age = 0
        private set
    
    init {
        this.nom = nom
    }
    
    fun grandir() {
        age += 1
    }
    
}

fun main(args: Array<String>) {
   val humain = Personne("Jean")
   println(humain.nom)
   println(humain.age)
   humain.grandir()
   println(humain.age)
}

Ainsi, la liste des paramètres est précisée juste après le nom de classe et entre parenthèses. En outre, pour chaque paramètre, telle la déclaration d’un paramètre de fonction, il faut préciser le nom de la variable avant son type.

Remarquez également qu’on pouvait ne par attribuer de valeur immédiatement à la propriété « nom » (ligne 2), parce que cela a été fait dans le bloc d’initialisation init (lignes 6-8).

Et donc, grâce au constructeur primaire, c’est lors de la construction de l’instance que nous attribuons une valeur pour le nom (ligne 17).

Mais nous pouvons simplifier ce code :

class Personne(val nom: String) {
    var age = 0
        private set
    
    fun grandir() {
        age += 1
    }
    
}

fun main(args: Array<String>) {
   val humain = Personne("Jean")
   println(humain.nom)
   println(humain.age)
   humain.grandir()
   println(humain.age)
}

Ce que nous avons fait ici :

• nous avons préfixé le paramètre « nom » du constructeur primaire par le mot-clef « val ». De cette manière, Kotlin ajoutera automatiquement une propriété « nom » en lecture seule, et dont la valeur sera celle passée en paramètre lors de la construction de l’instance (ligne 11) ;
• de ce fait, nous avons pu supprimer le bloc init, devenu inutile.

Et si nous faisions de même pour la propriété « age » ?

class Personne(val nom: String, var age: Int = 0) {
    
    fun grandir() {
        age += 1
    }
    
}

fun main(args: Array<String>) {
   val humain = Personne("Jean")
   println(humain.nom)
   println(humain.age)
   humain.grandir()
   println(humain.age)
   
   val deuxiemeHumain = Personne("Alice", 18)
   println(deuxiemeHumain.age)
}

Nous avons donc :

• ajouté le paramètre « age » dans le constructeur primaire avec une valeur par défaut ;
• supprimé la propriété « age » de la classe.

En revanche, rien ne nous empêche ici de modifier l’âge depuis l’extérieur. Et si nous avions voulu utiliser une propriété en lecture seule à la place, la méthode « grandir() » n’aurait pas pu fonctionner.

C’est donc l’inconvénient de cette technique : l’impossibilité de restreindre l’accès au setter.

Si nous voulons d’autres constructeurs, il faut les déclarer à l’intérieur de la classe et les baser sur le constructeur principal.

class Personne(val nom: String, var age: Int) {
    
    constructor(nom: String) : this(nom, 0) {
        // Nous pouvons même effectuer d'autres tâches
        // d'initialisation ici
        println("Dans un constructeur auxiliaire")
    }
    
    fun grandir() {
        age += 1
    }
    
}

fun main(args: Array<String>) {
   val humain = Personne("Jean")
   println(humain.nom)
   println(humain.age)
   humain.grandir()
   println(humain.age)
   
   val deuxiemeHumain = Personne("Alice", 18)
   println(deuxiemeHumain.age)
}

J’ai volontairement supprimé la valeur par défaut du paramètre « age » dans le constructeur principal afin que l’exemple soit plus pédagogique.

C’est donc le mot-clef constructor qui permet de déclarer un constructeur auxiliaire. De prime abord, sa signature ressemble énormément à la signature d’une fonction. Mais vous avez peut-être remarqué l’appel à this(nom, 0)juste avant les accolades. C’est l’équivalent de l’appel à super() du Java/C++ et qui permet d’abord d’initialiser l’instance en faisant appel au constructeur primaire (donc ici nous initialisons l’âge à zéro). Enfin, il est également possible d’effectuer d’autres instructions après cet appel, grâce au code situé entre les accolades.

En Kotlin, il est également possible de déclarer des classes imbriquées.

class Externe(val a: Int) {
    class Interne(var b: Int) {
        fun augmenterB() {
            b += 1
        }
    }
}

fun main(args: Array<String>) {
   val externe = Externe(3)
   val interne = Externe.Interne(2)
   
   println(externe.a)
   println(interne.b)
   interne.augmenterB()
   println(interne.b)
}

Prêtez bien attention d’ailleurs aux différentes casses (majuscule/minuscule) des différentes instances et classes, en particulier lors de la création de la variable interne (ligne 10).

Les Objets regroupent des fonctions que l’on peut appeler sans devoir instancier le modèle en question (toutes leurs méthodes et valeurs sont des équivalents des méthodes et valeurs statiques de Java/C++).

Un Objet est en quelque sorte une classe Singleton, pour ceux qui connaissent ce patron de conception.

object Math {
    fun moyenne(valeurs: Array<Int>): Double {
        if (valeurs.isEmpty()) return 0.0
        return (valeurs.sum() / valeurs.size).toDouble()
    }
    
    fun min(valeurs: Array<Int>): Int {
        return valeurs.min() ?: 0
    }
}

fun main(args: Array<String>) {
   println(Math.moyenne(arrayOf(2,10,18,13)))
   println(Math.min(arrayOf(3,1,10)))
}

Ainsi, pour accéder aux méthodes « moyenne » et « min », je n’ai pas eu à créer d’instance de la classe « Math ». En revanche, j’accède à ces méthodes « en tant que propriétés de la classe Math ».

Attention toutefois : un objet ne peut être imbriqué que dans un autre objet ou une classe non interne.

Il est possible d’ajouter des méthodes « statiques » dans une classe grâce à la fonctionnalité « objet compagnon ».

class Personne(val nom: String, age: Int)
{
    var age = age
        private set
    
    fun grandir()
    {
        age += 1
    }
    
    companion object Math {
        fun moyenne(valeurs: Array<Int>): Double {
            if (valeurs.isEmpty()) return 0.0
            return (valeurs.sum() / valeurs.size).toDouble()
        }

        fun min(valeurs: Array<Int>): Int {
            return valeurs.min() ?: 0
        }
    }
}

fun main(args: Array<String>) {
   println(Personne.moyenne(arrayOf(2,10,18,13)))
   println(Personne.min(arrayOf(3, 12, 8)))
   val guillaume = Personne("Guillaume", 15)
   println(guillaume.nom)
}

• Je déclare un objet compagnon dans la classe « Personne » : je peux donc directement appeler les méthodes « moyenne » et « min » de la classe « Personne », sans même avoir instancié de variable du modèle « Personne ». Ce sont des méthodes statiques ajoutées à la classe « Personne ».

Nous pouvons même ignorer le nom du compagnon objet dans la classe Personne :

class Personne(val nom: String, age: Int)
{
    var age = age
        private set
    
    fun grandir()
    {
        age += 1
    }
    
    companion object { // Il n’y a plus le nom Math
        fun moyenne(valeurs: Array<Int>): Double {
            if (valeurs.isEmpty()) return 0.0
            return (valeurs.sum() / valeurs.size).toDouble()
        }

        fun min(valeurs: Array<Int>): Int {
            return valeurs.min() ?: 0
        }
    }
}

fun main(args: Array<String>) {
   println(Personne.moyenne(arrayOf(2,10,18,13)))
   println(Personne.min(arrayOf(3, 12, 8)))
   val guillaume = Personne("Guillaume", 15)
   println(guillaume.nom)
}

Les fonctions d’extension permettent d’enrichir une classe déjà existante (mais juste dans le contexte du projet dans lequel on se situe, évidemment).

Vous connaissez déjà certaines fonctions d’extension : les fameuses fonctions map/filter/reduce que nous avons utilisées avec certaines collections.

Ainsi, le type « Array » est basé sur les tableaux natifs de Java, lesquels ne possèdent aucune des trois méthodes.

On peut même, de cette manière, augmenter le type « String », pourtant à l’origine immuable en Java.

fun String.capitalize() : String {
    return "${this[0].toUpperCase()}${this.substring(1)}"
}

fun main(args: Array<String>) {
   println("hello".capitalize())
}

Ici, j’ai défini une nouvelle méthode « capitalize() » sur la classe « String » :

• c’est presque une fonction classique : il faut juste penser à préfixer le nom de la méthode par le nom de la classe destinatrice (y compris nos propres types) suivi d’un point ;
• à l’intérieur de la fonction, « this » représente l’instance de l’objet sur lequel a été appelée la méthode (pour les non-habitués à Java, c’est un concept de la programmation orientée objet dont nous reparlerons ultérieurement) ;
• évidemment, nous ne sommes pas limités à une fonction sans arguments ;
• de même, nous pouvons utiliser la simple syntaxe d’une expression en valeur de retour.

Un autre exemple intéressant, c’est d’écrire une méthode pour les nombres premiers :

fun Int.estPremier() : Boolean {
    return (2 until this).none{this % it == 0}
}

fun main(args: Array<String>) {
   for (i in 1..20)
    {
        println("$i est premier ? ${if (i.estPremier()) "oui" else "non"}")
    }
}

Remarquez :

• 2 until 5 représente un intervalle commençant à 2 mais n’incluant pas 5 ;
• la fonction d’ordre supérieur « none » est une méthode présente dans les intervalles et permettant de vérifier qu’aucun élément ne vérifie la condition énoncée.

Une fonction d’extension a évidemment accès à l’ensemble des membres et méthodes publiques de la classe en question.

Mais il est aussi possible de définir une fonction d’extension sur un type « nullable » !

fun Int?.estPair() : Boolean {
    if (this == null) return false
    return this % 2 == 0
}

fun main(args: Array<String>) {
   val i:Int? = null
   val j = 3
    
   println(i.estPair())
   println(j.estPair())
}

Et donc, comme l’extrait de code précédent le démontre, nous pouvons éventuellement tester si la valeur est « null » afin de réaliser un traitement adéquat.

Tout comme nous pouvons ajouter des méthodes aux classes existantes, nous pouvons ajouter des propriétés.

val String.demiTaille: Int
    get() = length / 2

fun main(args: Array<String>) {
   println("Hello World !".demiTaille)
}

Il faut absolument respecter cette forme :

1. on définit le type de la propriété sans l’initialiser ;
2. on ajouter un « getter » pour la propriété (d’ailleurs ici, il fait appel à une autre propriété de la classe « String » : length).

Cela fonctionne également avec les génériques, que nous verrons sous peu.

val <T> Array<T>.demiTaille : Int
    get() = size / 2

fun main(args: Array<String>) {
   println(arrayOf(2,3,4,5,6).demiTaille)
   println(arrayOf(1.0,2.0,3.0,4.0,5.0).demiTaille)
}

Tout compagnon d’objet de classe peut se voir ajouter des fonctions et valeurs. Le mécanisme est le même que pour les fonctions et propriétés d’extension.

class Vecteur(val dx: Double, val dy: Double) {
    companion object {
        
    }
}

// Mince l'auteur original a oublie d'ajouter le vecteur nul en tant que valeur de classe
// Pas grave, je vais le faire moi-même, localement

val Vecteur.Companion.NUL: Vecteur
    get() = Vecteur(0.0, 0.0)

fun main(args: Array<String>) {
   println(Vecteur.NUL.dx)
   println(Vecteur.NUL.dy)
}

Ainsi, j’ai appliqué une propriété d’extension sur le compagnon d’objet de la classe « Vecteur ». Ici, le compagnon d’objet s’appelle tout simplement « Companion », étant donné qu’il est anonyme dans la classe que l’on souhaite étendre. Pour être plus complet, j’aurais d’ailleurs pu ajouter une extension de méthode sur la classe « Vecteur » elle-même afin d’en calculer la norme (la longueur du vecteur).

Nous reparlerons des objets compagnons ultérieurement.

I-I-1. Fonction générique▲

fun <T> afficher(a: T, b: T) {
    println("A est $a, B est $b")
}

fun main(args: Array<String>) {
   afficher(3,2)
   afficher(2.0,10.0)
   afficher("Hello", "World !")
}

fun <T, U> afficher(a: T, b: U) {
    println("A est $a, B est $b")
}

fun main(args: Array<String>) {
   afficher(3, 'a')
   afficher(2.0, "euros")
   afficher("Bonjour", "les codeurs !")
}

fun <T> afficher(a: T, b: Int) {
    println("A est $a, B est $b")
}

fun main(args: Array<String>) {
   afficher(3, 10)
   afficher(2.0, 20)
   afficher("Bonjour", 30)
}

fun <T, U> afficher(a: U, b: T) {
    println("A est $a, B est $b")
}

fun main(args: Array<String>) {
   afficher(3, 'a')
   afficher(2.0, "euros")
   afficher("Bonjour", "les codeurs !")
}

I-I-2. Classe générique▲

class MaPaire<T, U>(val prem: T, val deux: U)

fun main(args: Array<String>) {
   val paire = MaPaire(10, "euros")
   println(paire.prem)
   println(paire.deux)
}

I-I-3. Aller plus loin▲

II-A-1. Héritage simple▲

open class Vehicule(nombreRoues: Int, nombrePlaces)

class Velo : Vehicule(2,1)
class Automobile(nombreRoues: Int, nombrePlaces: Int) : Vehicule(nombreRoues, nombrePlaces)

fun main(args: Array<String>) {
   val monVehicule = Vehicule(3, 1)
   // println(monVehicule.nombreRoues): erreur ! Sera resolue plus tard
   // println(monVehicule.nombrePlaces): erreur ! Sera resolue plus tard
   val monVelo = Velo()
   // println(monVelo.nombreRoues) : erreur ! Sera resolue plus tard
   // println(monVelo.nombrePlaces) : erreur ! Sera resolue plus tard
   val maVoiture = Automobile(4,4)
   // println(maVoiture.nombreRoues) : erreur ! Sera resolue plus tard
   // println(maVoiture.nombrePlaces) : erreur ! Sera resolue plus tard
}

open class Vehicule(val nombreRoues: Int, val nombrePlaces: Int)
class Velo : Vehicule(2,1)
class Automobile(nombreRoues: Int, nombrePlaces: Int) : Vehicule(nombreRoues, nombrePlaces)

fun main(args: Array<String>) {
   val monVehicule = Vehicule(3, 1)
   println(monVehicule.nombreRoues)
   println(monVehicule.nombrePlaces)
   
   val monVelo = Velo()
   println(monVelo.nombreRoues)
   println(monVelo.nombrePlaces)
   
   val maVoiture = Automobile(4,4)
   println(maVoiture.nombreRoues)
   println(maVoiture.nombrePlaces)
}

open class Vehicule(nombreRoues: Int, nombrePlaces: Int)
{
   val nombreRoues: Int
   val nombrePlaces: Int
    
   init {
       this.nombreRoues = nombreRoues
       this.nombrePlaces = nombrePlaces
   }
}

class Velo : Vehicule(2,1)
class Automobile(nombreRoues: Int, nombrePlaces: Int) : Vehicule(nombreRoues, nombrePlaces)

fun main(args: Array<String>) {
   val monVehicule = Vehicule(3, 1)
   println(monVehicule.nombreRoues)
   println(monVehicule.nombrePlaces)
   
   val monVelo = Velo()
   println(monVelo.nombreRoues)
   println(monVelo.nombrePlaces)
   
   val maVoiture = Automobile(4,4)
   println(maVoiture.nombreRoues)
   println(maVoiture.nombrePlaces)
}

open class Vehicule(val nombreRoues: Int, val nombrePlaces: Int)


class Velo : Vehicule(2,1)
open class Automobile(nombreRoues: Int, nombrePlaces: Int) : Vehicule(nombreRoues, nombrePlaces)

class Voiture: Automobile(4,4)

II-A-2. La visibilité protected▲

II-A-3. Héritage et constructeurs secondaires▲

open class Vehicule(val nombreRoues: Int, val nombrePlaces: Int)
class Velo: Vehicule(4,4) {
    constructor(): super(3,3)
}

open class Vehicule(val nombreRoues: Int, val nombrePlaces: Int)
class Velo: Vehicule {
    constructor(): super(3,3)
    constructor(moitieNombrePlaces: Int): super(4, moitieNombrePlaces * 2)
}

fun main(args: Array<String>) {
    val velo1 = Velo()
    println(velo1.nombrePlaces)
    println(velo1.nombreRoues)
    
    val velo2 = Velo(2)
    println(velo2.nombrePlaces)
    println(velo2.nombreRoues)
}

II-B-1. Héritage de classes abstraites▲

abstract class Figure {
    abstract val nombreCotes: Int
    
    abstract fun perimetre(): Double
    abstract fun aire(): Double
    
    val nom = "Figure"
    
    fun afficher() {
        println("Affichage de la figure sur l’écran")
    }
}

class Carre(val longueurCotes: Double): Figure() {
    override val nombreCotes = 4
    
    override fun perimetre(): Double {
        return 4 * nombreCotes;
    }
    
    override fun aire(): Double {
        return nombreCotes * longueurCotes;
    }
}

fun main() {
    // Ceci ne compilera pas => val figure0 = Figure();
    val figure1 = Carre(10.0)
    println(figure1.perimetre()) // affiche 40.0
    println(figure1.aire()) // affiche 100.0
}

II-B-2. Héritage d’interfaces▲

interface Figure {
    abstract val nombreCotes: Int
    
    abstract fun perimetre(): Double
    abstract fun aire(): Double
    
    fun afficher() {
        println("Affichage de la figure sur l’écran")
    }
}

class Carre(val longueurCotes: Double): Figure {
    override val nombreCotes = 4
    
    override fun perimetre(): Double {
        return 4 * longueurCotes;
    }
    
    override fun area(): Double {
        return longueurCotes * longueurCotes;
    }
}

fun main() {
    // Ceci ne compilera pas => val figure0 = Figure();
    val figure1 = Carre(10.0)
    println(figure1.perimetre())
    println(figure1.aire())
}

interface Figure {
    val nombreCotes: Int
    
    fun perimetre(): Double
    fun aire(): Double
    
    fun afficher() {
        println("Affichage de la figure sur l’écran")
    }
}

class Carre(val longueurCotes: Double): Carre {
    override val nombreCotes = 4
    
    override fun perimetre(): Double {
        return 4 * longueurCotes;
    }
    
    override fun aire(): Double {
        return longueurCotes * longueurCotes;
    }
}

fun main() {
    // Ceci ne compilera pas => val figure0 = Figure();
    val figure1 = Carre(10.0)
    println(figure1.perimeter())
    println(figure1.area())
}

interface PeutVoler {
    fun voler() { println("Je vole") }
}

interface PeutNager {
    fun nager() { println("Je nage") }
}

class Canard : PeutVoler, PeutNager {
    
}

class Poisson : PeutNager {
    
}



fun main() {
    val c = Canard()
    c.voler()
    c.nager()
    
    val p = Poisson()
    p.nager()
}

II-B-3. Héritage simultané d’une classe et d’interfaces▲

interface PeutVoler {
    fun voler() { println("Je vole") }
}

interface PeutNager {
    fun nager() { println("Je nage") }
}

abstract class Animal

class Canard: Animal(), PeutVoler, PeutNager {
    
}

class Poisson : Animal(), PeutNager {
    
}



fun main() {
    val c = Canard()
    c.voler()
    c.nager()
    
    val p = Poisson()
    p.nager()
}

II-B-4. Le polymorphisme▲

interface PeutVoler {
    fun voler() { println("Je vole") }
}

interface PeutNager {
    fun nager() { println("Je nage") }
}

abstract class Animal {
    abstract fun bouger()
}

class Canard: Animal(), PeutVoler, PeutNager {
    override fun bouger() {
        voler()
        nager()
    }
}

class Poisson : Animal(), PeutNager {
    override fun bouger() {
        nager()
    }
}



fun main() {
    val ferme = arrayOf<Animal>(Canard(), Poisson(), Poisson(), Canard())
    for (animal in ferme) animal.bouger()
}

Nous avons déjà rencontré les objets compagnons auparavant dans ce tutoriel lorsque nous souhaitions ajouter des fonctionnalités à des classes existantes(section V-H).

De manière générale, les objets compagnons permettent de définir des propriétés/méthodes comme appartenant à une classe, au lieu de les faire appartenir aux instances de cette classe :

class Math {
    companion object {
        val PI = 3.1415927
        fun carre(x: Double) = x*x
    }
}

fun main() {
    println(Math.carre(Math.PI))
}

Ainsi, j’ai défini une classe « Math », contenant une constante PI et une fonction carre. Elles sont directement accessibles via la syntaxe Math.. C’est l’équivalent des propriétés et méthodes statiques du langage Java.

Rien ne nous interdit de déclarer un objet compagnon dans une classe normalement prévue pour créer des instances :

class Livre(val contenu: String, val pages: Int) {
    companion object {
        val possesseur = "Moi"
    }
}

fun main() {
    val l = Livre("Je suis un livre", 100)
    println(l.contenu)
    // Ceci ne compile pas : println(l.possesseur )
    println(Livre.possesseur )
}

On remarque donc que les éléments définis par un objet compagnon ne restent accessibles que par la syntaxe Classe..

En pratique, de nombreuses fonctions attendent des instances de classes, qui implémentent une interface particulière, en paramètre. Et dans de nombreux cas, nous sommes amenés à créer des instances de telles classes, juste avant d’appeler lesdites fonctions et sans nous en servir une fois cette fonction terminée. En clair, on a créé un objet temporaire juste pour pouvoir satisfaire la fonction.

Par exemple :

interface Appelable {
    abstract val nom: String
}

fun direBonjourA(a: Appelable) {
    println("Bonjour ${a.nom} !")
}

class Personne(nom: String): Appelable {
    override val nom = nom
}

fun main() {
    val leo = Personne("Leo")
    direBonjourA(leo)
}

Ici, nous avons créé une variable « leo », juste pour pouvoir la passer à la fonction « direBonjour » (l’exemple n’est pas très représentatif de la problématique, je vous l’accorde).

Les classes anonymes, fonctionnalité qui existe notamment déjà en Java, permettent de contourner cette problématique.

interface Appelable {
    abstract val nom: String
}

fun direBonjourA(a: Appelable) {
    println("Bonjour ${a.nom} !")
}

fun main() {
    direBonjourA(object: Appelable {
        override val nom = "Leo"
    })
}

Ainsi, nous avons pu appeler la fonction « direBonjourA » sans même avoir eu à créer un objet de type « Personne » (qui du coup n’est plus nécessaire). Il s’agit simplement d’un « héritage d’interface » local. Évidemment, les interfaces n’ayant pas de constructeur, il ne faut pas de parenthèses lors de la définition de l’interface anonyme.

Il est possible de faire la même chose si le paramètre attendu est une classe :

abstract class Appelable(val nom: String) {}

fun direBonjourA(a: Appelable) {
    println("Bonjour ${a.nom} !")
}

fun main() {
    direBonjourA(object: Appelable("Leo"){
    })
}

Veuillez noter l’appel du constructeur parent lors de la définition de la classe anonyme. Tout comme on l’aurait fait pour définir une classe standard.

Dans les deux cas, classe ou interface, la dénomination officielle est « expression objet ». C’est important, car dans la documentation officielle, c’est sous ce nom qu’on y fait référence.

Enfin, comme dans toute classe, on peut redéfinir de la même manière les méthodes et propriétés de la hiérarchie, voire en ajouter d’autres.

Les classes de données (data classes) peuvent souvent nous simplifier beaucoup de choses.

Prenons un exemple simple :

data class Personne(val prenom: String, val nom: String, age: Int)

Vous avez sans doute remarqué le mot-clef data.

Grâce à cela, nous avons un certain nombre de choses déjà implémentées pour nous, rien que par cet ajout. Entre autres :

• une définition automatique des méthodes « equals » et « hashCode » : ce qui nous permet d’utiliser directement l’opérateur == pour comparer des objets de type « Personne » ;
• une définition automatique de la méthode  toString() : ce qui nous permet d’afficher proprement les objets de type « Personne », avec une commande println par exemple ;
• une définition automatique des méthodes component1, component2 et component3. Ici jusqu’à trois, car nous avons trois paramètres dans notre constructeur. Ces méthodes permettent de déconstruire les objets de type « Personne », comme nous l’avons vu auparavant dans ce tutoriel (Section II-i).

En revanche, il y a des restrictions :

• le constructeur primaire doit avoir au moins un paramètre ;
• tous les paramètres du constructeur primaire doivent être marqués soit comme« val », soit comme « var » ;
• ces classes ne peuvent être ni « open », ni « abstract » (donc non héritables), ni « inner » (donc non internes), ni « sealed ». Nous verrons ce que sont les classes « sealed » dans la section suivante.

Il y a d’autres restrictions, je vous invite à consulter la documentation officielledocumentation sur les data classes pour approfondir le sujet.

Lorsque l’on veut être certain qu’une classe ne soit pas héritable à l’infini, mais qu’en revanche seulement un certain nombre de classes en soient héritées, on peut la définir comme « scellée ».

De ce fait, toutes les classes filles doivent être déclarées dans le même fichier que cette classe mère :

sealed class Expression
data class Constante(val nombre: Double): Expression()
data class Somme(val op1: Expression, val op2: Expression): Expression()
object NaN: Expression()

Ici, je me suis contenté d’adapter l’exemple officiel.

Bien évidemment, ici, « NaN » est bien une classe « object » au sens propre du terme et non une classe anonyme.

La classe « Expression » ne peut avoir d’autre classe fille que les classes « Constante », « Somme » et « Nan ». Et l’on peut utiliser le polymorphisme dans une fonction dédiée pour évaluer des instances de la classe « Expression ». Ce n’est pas difficile à imaginer, à l’aide d’un algorithme récursif.

Les classes énumérations sont des énumérations plus puissantes que dans un certain nombre de langages, dont Java.

Une énumération est un type dont l’ensemble des valeurs a été défini à l’avance. C’est donc équivalent aux classes scellées, mais pour de simples valeurs.

De bonnes notions candidates pour les énumérations peuvent être : les mois de l’année, les points cardinaux, les langues vivantes enseignées dans un établissement…

Un exemple simple pour commencer

enum class Direction {
    Nord, Est, Sud, Ouest
}

fun main() {
    val destination = Direction.Nord
    println(when (destination) {
      Direction.Nord -> "Je vais au nord"
        Direction.Sud -> "Je vais au sud"
          else -> "Direction interdite !"  
    })
}

Prenons maintenant une énumération RGB, qui permettrait d’obtenir du rouge, du vert ou du bleu. Nous pouvons aussi lire la valeur (hexadécimale, mais codée sous forme d’entier) de la couleur choisie :

enum class RVB(val hexa: Int) {
    Rouge(0xFF0000),
    Vert(0x00FF00),
    Bleu(0x0000FF)
}

fun main() {
    val couleur = RVB.Rouge
    println("0x${Integer.toHexString(color.hexa)}")
}

Ainsi, grâce au constructeur primaire de l’énumération RVB, nous pouvons en personnaliser et lire la valeur associée.

Allons un peu plus loin :

enum class RVB(val r: Int, val g: Int, val b: Int) {
    rouge(255, 0, 0),
    vert(0, 255, 0),
    bleu(0, 0, 255),
    noir(0,0,0),
    blanc(255,255,255)
}

fun main() {
    val color = RVB.noir
    println(color.r)
}

Une énumération peut aussi avoir des éléments abstraits, que les différentes valeurs doivent alors redéfinir en tant que classes anonymes, certes avec une syntaxe épurée :

enum class Animal {
    Chien {
        override fun crier() = "YapYap!"
    },
    Chat {
        override fun crier() = "Miaou!"
    };
    abstract fun crier(): String
}
fun main() {
    val animal = Animal.Chat
    println(animal.crier())
}

Attention à ne pas oublier le point-virgule après la définition des valeurs !

Veuillez également remarquer que les éléments n’ont pas besoin de la syntaxe Object : {afin de redéfinir la base de l’énumération.

Sachez aussi qu’il est possible, de manière similaire, d’implémenter des interfaces dans une énumération. N’hésitez pas à aller consulter la documentation officielle si besoin.

Kotlin permet de surcharger un certain nombre d’opérateurs au sein de nos propres classes.

Ainsi, on pourrait additionner deux dates de calendrier directement avec la notation d1 + d2, on pourrait multiplier deux matrices à l’aide de m1 * m2…

Comprenez bien que tout mécanisme permettant d’augmenter une classe, donc l’héritage ou les fonctions d’extension, permet la surcharge d’opérateurs.

Évidemment, le but ne sera pas d’être exhaustif, mais simplement de vous présenter un simple exemple. Je vous invite donc à vous rendre à la documentation officielleSurcharge d'opérateurs si vous souhaitez approfondir le sujet.

Soit une classe Fraction et une première tentative infructueuse d’additionner deux fractions :

class Fraction(val numerateur: Int, val denominateur: Int = 1)

fun main() {
    val a = Fraction(2)
    val b = Fraction(3,2)
    
    // Ceci ne compilera pas => println(a+b)
}

Une manière élégante de résoudre ce problème consiste à définir l’opérateur + pour la classe Fraction. Mais attention, en Kotlin, les noms des fonctions à redéfinir ne correspondent pas aux noms des opérateurs ! D’où la bonne idée de regarder la documentation officielle.

En l’occurrence, la fonction à redéfinir pour l’addition s’appelle « plus » et prend le 2^e opérande de l’addition en paramètre :

class Fraction(val numerateur: Int, val denominateur: Int = 1){
    override fun toString(): String = "$numerateur/$denominateur"
}

operator fun Fraction.plus(autre: Fraction): Fraction {
    return Fraction(numerateur * autre.denominateur + autre.numerateur * denominateur, denominateur * autre.denominateur)
}

fun main() {
    val a = Fraction(2)
    val b = Fraction(3,2)
    
    println(a+b)
}

Et dans une version plus classique, avec une simple méthode :

class Fraction(val numerateur: Int, val denominateur: Int = 1){
    override fun toString(): String = "$numerateur/$denominateur"
    
    operator fun plus(autre: Fraction): Fraction {
    return Fraction(numerateur * autre.denominateur + autre.numerateur * denominateur, denominateur * autre.denominateur)
}

}
fun main() {
    val a = Fraction(2)
    val b = Fraction(3,2)
    
    println(a+b)
}

Dans les deux cas, vous pouvez remarquer l’utilisation du mot-clef « operator », obligatoire pour que la méthode soit reconnue en tant que surcharge d’opérateur !