IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Comprendre le casting de type par le biais du mot-clé when avec le langage Kotlin
Un billet de blog de Laurent Bernabé

Le , par tails

0PARTAGES

Contrairement au Java, bien qu'il existe un mot-clé dédié à cet effet, le casting de type se fait à l'aide d'une structure de contrôle. Elle s'appelle when : c'est en quelque sorte la structure switch de Java mais bien plus puissante. Par contre ici, nous nous limiterons à l'une des utilisations les plus simple afin de pouvoir effectuer un casting de type.

Soit la hiérarchie de classes suivantes (vous noterez que créer une classe en Kotlin est bien plus simple qu'en Java) :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
class Figure
class Rectangle(val largeur: Double val longueur: Double) : Figure {
    fun perimetre(): Double = 2*(largeur + longueur)
}
class Cercle(val centre: Point, val rayon: Double) : Figure {
   fun aire() : Double {
       return 2*Math.PI*rayon
   }
}
Ici je déclare une classe concrète Figure qui ne fait absolument rien.
Quatre remarques importantes :
  • On déclare le constructeur en même temps que la classe. (Comment alors définir plusieurs constructeurs ? Cela sera l'objet d'un billet ultérieur),
  • Pour dériver une classe, on utilise la syntaxe ": <Classe de Base>", avec éventuellement les paramètres renseignés pour le constructeur de la classe de base (Idem pour le cas des constructeurs multiples pour la classe de base : ce sera l'objet d'un billet ultérieur),
  • On déclare le type d'une variable avec la syntaxe "val <NomVariable> : <Type>" , comme vu dans le billet précédent sur l'immutabilité,
  • Enfin le fait de déclarer un paramètre comme val permet de créer automatiquement un getter (et aucun setter) pour la variable déclarée tandis que l'utilisation de var permet de générer automatiquement à la fois un getter et un setter pour la dite propriété.


Je vous prie de ne pas attacher trop d'importante à la syntaxe de déclaration de fonctions/méthodes (notamment aire() et perimetre()) pour l'instant.

Ainsi, le code suivant est valide :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
class Adress(val ville: String, val codePostal: Int)
class Person(val nom: String, val prenom: String, var adress: Adress)

val noemie = Person("Tartempion", "Noemie", Adress("Troyes", 10420))
println(noemie.adress.ville) // afficher du texte sur la sortie standard est bien plus simple en Kotlin.
noemie.adress = ("Strasbourg", 67000)
// En revanche le code suivant provoquera une erreur de compilation
noemie.prenom = "Toto"
//De même celui-là
noemie.adress.codePostal = 15200
Remarquez aussi que l'on crée une instance de classe sans le mot-clé new, contrairement au Java.

Il me manque aussi la classe Point :
Code : Sélectionner tout
1
2
class Point(val x: Double, val y: Double)
Nous pouvons donc écrire le code suivant :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
val allFigures = arrayOf(Rectangle(10.0, 20.0), Cercle(Point(5.0, -15.0), 20.0) // Déclare un simple tableau de Figures (polymorphique)
// Ecriture equivalente : val allFigures = arrayOf<Figures>(Rectangle(10.0, 20.0), Cercle(Point(5.0, -15.0), 20.0) : le precent code fait appel à l'inference de type

for (currentFigure in allFigures) {
   when (currentFigure) {
       is Rectangle -> println("Mon permimetre est de ${currentFigure.perimetre()}")
       is Cercle -> println("Mon aire est de ${currentFigure.aire()}")
   }
}
Plusieurs remarques sur le code précédent :
  • La boucle for est simplifiée par rapport au Java : écrire "for (valeur: Int = 0; valeur < 10; valeur++)" ou tout code de ce genre est totalement interdit en Kotlin. Il faut obligatoirement passer par un itérateur !
  • On teste dans chaque branche de when à l'aide du mot clé if, et on ne met ni point-virgule, ni virgule ... rien en fin de ligne de chaque branche !!!
  • Ici je crée une TemplateString : dès que le compilateur verra $a dans la chaîne "Voici a : $a", il remplacera la chaîne "$a" par la valeur de a. Par contre si l'on doit utiliser une expression, il faut l'englober dans des accolades, comme dans le code.
  • Enfin, l'aspect le plus inattendu, le SmartCast. Une fois que le compilateur voit is Rectangle, c'est comme si il avait aussitôt transformé lui-même la variable currentFigure en instance de Rectangle, de sorte que la méthode perimetre() peut être directement appellée. Mais attention, cela ne vaut que pour cette branche-ci ! De même pour la branche is Cercle.


Voilà ! En espérant ne pas trop vous avoir noyé et que vous avez pris du plaisir à lire ce billet !

Une erreur dans cette actualité ? Signalez-le nous !