Voir le flux RSS

tails

[Actualité] [Kotlin] Casting par le biais du mot-clé "when"

Noter ce billet
par , 30/08/2017 à 12h11 (1124 Affichages)
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
1
2
class Point(val x: Double, val y: Double)
Nous pouvons donc écrire le code suivant :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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 !

Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Viadeo Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Twitter Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Google Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Facebook Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Digg Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Delicious Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog MySpace Envoyer le billet « [Kotlin] Casting par le biais du mot-clé "when" » dans le blog Yahoo

Mis à jour 31/08/2017 à 12h05 par tails (typo code)

Catégories
Java

Commentaires