Dans ce tutoriel vous allez découvrir la puissante de la surcharge des opérateurs et comment les utiliser avec votre .
De manière général une convention permet d’établir des règles de fonctionnement . Kotlin utilise les conventions pour faire correspondre une fonction à un caractère.
Un opérateur dans kotlin est un caractère à qui on fait correspondre une fonction par convention. Par exemple l’opérateurs plus(+), ou minus(-) . Donc par convention a+b peut se transformer en a.plus(b) et a-b peut se transformer en a.minus(b) .
Comme dans kotlin, Java propose un liste d’opérateur que vous pouvez utiliser avec un certains types de donnée .Par exemple pour concaténer une chaîne de caractère et un nombre on utilise le l’opérateur + .Par contre java ne nous permet pas d’utiliser ces opérateurs pour nos propres types de donnée.
Contrairement à java Kotlin met à disposition un liste d’opérateur qui répond à la plus part des cas d’opérateur possible et vous permet d’utiliser ces opérateurs avec vos propres types de donnée en les surchargeant.
Table des matières
Surcharge des opérateurs
Kotlin vous permet de surcharger les opérateurs qu’il met à disposition avec vos propres types de données en implémentant chaque opérateur.
Pour que kotlin reconnait une fonction que vous avez surchargé comme étant un opérateur, vous devez la marquer avec le mot clé operator. Vous devez implémenter ces opérateurs en les déclarant comme fonction membre d’une classe ou comme extension de fonction.
Voici ci-dessous la liste des différents types d’opérateur dans kotlin
Opérations unaires
Opérateurs de préfixes unaires
Expression | Traduis en |
+a | a.unaryPlus() |
-a | a.unaryMinus() |
!a | a.not() |
Surcharge de l’opérateur –( unaryMinus )
fun main(){ val point= Point(10,5) println("Avant: $point") println("Apres: ${-point}") } data class Point(val x: Int, val y: Int) operator fun Point.unaryMinus():Point= Point(-x,-y)
Résultat:
Avant: Point(x=10, y=5)
Apres: Point(x=-10, y=-5)
Notez que la l’opérateur est implémenté avec une fonction d’ extension
Surcharge de l’opérateur !(not)
fun main(){ val point= Point(10,5) println("Avant: $point") println("Apres: ${!point}") } data class Point(val x: Int, val y: Int) operator fun Point.not():Point= Point(y,x)
Résultat:
Avant: Point(x=10, y=5)
Apres: Point(x=5, y=10)
Incréments et décréments
Expression | Traduis en |
a++ | a.inc() |
a– | a.dec() |
Surcharge de l’opérateur ++(inc )
fun main(){ var point= Point(10,5) println("Avant: $point") point++ println("Apres: $point") } data class Point(val x: Int, val y: Int) operator fun Point.inc():Point= Point(x+1,y+1)
Résultat:
Avant: Point(x=10, y=5)
Apres: Point(x=11, y=6)
Surcharge de l’opérateur –(dec )
fun main(){ var point= Point(10,5) println("Avant: $point") point-- println("Apres: $point") } data class Point(val x: Int, val y: Int) operator fun Point.dec():Point= Point(x -1,y -1)
Résultat:
Avant: Point(x=10, y=5)
Apres: Point(x=9, y=4)
Opérations binaires
Opérateurs arithmétiques
Expression | Traduis en |
a + b | a.plus(b) |
a – b | a.minus(b) |
a * b | a.times(b) |
a / b | a.div(b) |
a % b | a.rem(b) , a.mod(b) (deprecated) |
a..b | a.rangeTo(b) |
Surcharge de l’opérateur +(plus)
fun main(){ val point1= Point(10,5) val point2= Point(10,5) println(point1+point2) } data class Point(val x: Int, val y: Int) operator fun Point.plus(point: Point):Point= Point(x + point.x,y + point.y)
Résultat: Point(x=20, y=10)
Surcharge de l’opérateur -(minus)
fun main(){ val point1= Point(10,5) val point2= Point(3,2) println(point1-point2) } data class Point(val x: Int, val y: Int) operator fun Point.minus(point: Point):Point= Point(x - point.x,y - point.y)
Surcharge de l’opérateur *(times)
fun main(){ val point1= Point(10,5) val point2= Point(3,2) println(point1*point2) } data class Point(val x: Int, val y: Int) operator fun Point.times(point: Point):Point= Point(x * point.x,y * point.y)
Résultat:Point(x=30, y=10)
Example 2
fun main(){ val point1= Point(10,5) val point2= Point(3,2) println(point1 * 6) } data class Point(val x: Int, val y: Int) operator fun Point.times(valeur: Int):Point= Point(x * valeur,y * valeur)
Résultat:Point(x=60, y=30)
Surcharge de l’opérateur /(div)
fun main(){ val point1= Point(10,5) val point2= Point(3,2) println(point1/point2) } data class Point(val x: Int, val y: Int) operator fun Point.div(point: Point):Point= Point(x / point.x,y / point.y)
Résultat:Point(x=3, y=2)
Surcharge de l’opérateur %(rem)
fun main(){ val point1= Point(10,5) val point2= Point(3,2) println(point1 % point2) } data class Point(val x: Int, val y: Int) operator fun Point.rem(point: Point):Point= Point(x % point.x,y % point.y)
Résultat: Point(x=1, y=1)
Surcharge de l’opérateur .. (range)
fun main(){ val mRange= Point(1,1)..Point(10,10) if(Point(2,2) in mRange){ println("Point sélectionné") } else{ println("Pas de point sélectionné") } } data class Point(val x: Int, val y: Int):Comparable<Point>{ override fun compareTo(other: Point): Int=when { y != other.y -> (y - other.y) else -> (x - other.x) } }
Résultat:Point sélectionné
Opérateurs In
Expression | Traduis en |
a in b | b.contains(a) |
a !in b | !b.contains(a) |
Surcharge de l’opérateur in (contain)
data class Personne(val age:Int) class ListPersonne(val personnes:List<Personne>){ operator fun contains(personne: Personne)= personne in personnes }
Surcharge de l’opérateur !in (contain)
data class Personne(val age:Int) class ListPersonne(val personnes:List<Personne>){ operator fun contains(personne: Personne)= personne !in personnes }
Opérateur d’accès indexé
Expression | Traduis en |
a[i] | a.get(i) |
a[i, j] | a.get(i, j) |
a[i_1, …, i_n] | a.get(i_1, …, i_n) |
a[i] = b | a.set(i, b) |
a[i, j] = b | a.set(i, j, b) |
a[i_1, ..., i_n] = b | a.set(i_1, …, i_n, b) |
Surcharge de l’opérateur [i]
data class Personne(val age:Int) class ListPersonne(val personnes:List<Personne>){ operator fun get(i: Int)=personnes.get(i) }
Surcharge de l’opérateur [i,j]
data class Personne(val age:Int) class ListPersonne(val personnes:List<Personne> ){ operator fun get(i: Int,j: Int)=personnes.subList(i,j) }
Surcharge de l’opérateur [i] =b
data class Personne(val age:Int) class ListPersonne(val personnes:MutableList<Personne> ){ operator fun set(i,personne: Personne)=personnes.add(i,personne) }
Invoquer un opérateur
Expression | Traduis en |
a() | a.invoke() |
a(i) | a.invoke(i) |
a(i, j) | a.invoke(i, j) |
Surcharge de l’opérateur a()
fun main(){ val message=Message("SMS") message() } data class Message(val message: String) operator fun Message.invoke()= println(message)
Résultat:SMS
Surcharge de l’opérateur a(i)
fun main(){ val distance= Distance(10) println(distance(17)) } data class Distance(val distance: Int ) operator fun Distance.invoke(dt: Int)=distance+dt
Résultat: 27
Opérations d’affectation
Expression | Traduis en |
a += b | a.plusAssign(b) |
a -= b | a.minusAssign(b) |
a *= b | a.timesAssign(b) |
a /= b | a.divAssign(b) |
a %= b | a.remAssign(b) , a.modAssign(b) (deprecated) |
Surcharge de l’opérateur a += b
fun main(){ val distance =Distance(20) distance += 10 println(distance.distance) } data class Distance(var distance: Int ) operator fun Distance.plusAssign(valeur: Int){ distance += valeur }
Résultat: 30
Opérateurs d’égalité et d’inégalité
Expression | Traduis en |
a == b | a?.equals(b) ?: (b === null) |
a != b | !(a?.equals(b) ?: (b === null)) |
Surcharge de l’opérateur !=
data class Distance(val distance: Int ){ override fun equals(other: Any?): Boolean { if(this === other) return true if(other !is Distance) return false if(this.distance!= other.distance) return false return true } }
Opérateurs de comparaison
Expression | Traduis en |
a > b | a.compareTo(b) > 0 |
a < b | a.compareTo(b) < 0 |
a >= b | a.compareTo(b) >= 0 |
a <= b | a.compareTo(b) <= 0 |
data class Personne(val age:Int):Comparable<Personne>{ override fun compareTo(other: Personne): Int { return age.compareTo(other.age) } }
Conclusion
Voila,nous sommes à la fin de ce tutoriel sur la surcharge des opérateurs dans kotlin. J’espère que ce tutoriel vous aidera.A bientôt pour un nouveau tutoriel.
Autres ressources
https://kotlinlang.org/docs/reference/operator-overloading.html#in
Noe Joel Vigan, auteur de ce blog, est passionné par la programmation Android. Il a créé ce blog pour partager ses connaissances sur le développement d’application android. Il est Développeur Android Fullstack, ce qui lui permet de complètement mettre en place le Backend de ses applications sur Google Cloud à défaut d’utiliser FireBase.