la surcharge des operateurs dans kotlin

La surcharge des opérateurs dans kotlin

Partager
  •  
  •  
  •  
  • 1
  •  
  •  
    1
    Partage

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.

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

ExpressionTraduis 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

ABONNEZ-VOUS A LA NEWSLETTER
Rejoignez la communauté de développeur Android pour apprendre encore plus sur le dévéloppement d'application Android.
Nous détestons les spam. Votre adresse email ne sera ni vendue ni partagée avec qui que ce soit.

Partager
  •  
  •  
  •  
  • 1
  •  
  •  
    1
    Partage
  • 1
    Partage

Laisser un commentaire

Résoudre : *
24 − 7 =


%d blogueurs aiment cette page :