Dans cet article, vous en apprendrez davantage sur la surcharge d'opérateurs (définissez le fonctionnement de l'opérateur pour les types définis par l'utilisateur comme les objets) à l'aide d'exemples.
Lorsque vous utilisez un opérateur dans Kotlin, sa fonction membre correspondante est appelée. Par exemple, l'expression se a+btransforme en a.plus(b)sous le capot.
fun main(args: Array) ( val a = 5 val b = 10 print(a.plus(b)) // print(a+b) )
Lorsque vous exécutez le programme, la sortie sera:
15
En fait, la plus()fonction est surchargée pour fonctionner avec divers types de base Kotlin et String.
// + opérateur pour les types de base operator fun plus (other: Byte): Int operator fun plus (other: Short): Int operator fun plus (other: Int): Int operator fun plus (other: Long): Long operator fun plus (other: Float): Float operator fun plus (other: Double): Double // pour l'opérateur de concaténation de chaînes fun String? .plus (other: Any?): String
Vous pouvez également définir le fonctionnement de l'opérateur pour les objets en surchargeant sa fonction correspondante. Par exemple, vous devez définir le fonctionnement de l' +opérateur pour les objets en surchargeant la plus()fonction.
Exemple: surcharge + opérateur
fun main(args: Array) ( val p1 = Point(3, -8) val p2 = Point(2, 9) var sum = Point() sum = p1 + p2 println("sum = ($(sum.x), $(sum.y))") ) class Point(val x: Int = 0, val y: Int = 10) ( // overloading plus function operator fun plus(p: Point) : Point ( return Point(x + p.x, y + p.y) ) )
Lorsque vous exécutez le programme, la sortie sera:
somme = (5, 1)
Ici, la plus()fonction est marquée d'un operatormot-clé pour indiquer au compilateur que l' +opérateur est surchargé.
L'expression p1 + p2se transforme en p1.plus(p2)sous le capot.
Exemple: - Surcharge de l'opérateur
Dans cet exemple, vous apprendrez à surcharger l' --opérateur. L'expression --ase transforme en a.dec()sous le capot.
La dec()fonction membre ne prend aucun argument.
fun main(args: Array) ( var point = Point(3, -8) --point println("point = ($(point.x), $(point.y))") ) class Point(var x: Int = 0, var y: Int = 10) ( operator fun dec() = Point(--x, --y) )
Lorsque vous exécutez le programme, la sortie sera:
point = (2, -9)
Souviens-toi de ça,
opérateur fun dec () = Point (- x, --y)
est équivalent à
opérateur fun dec (): Point (return Point (- x, --y))
Quelques points importants
1. Lorsque vous surchargez les opérateurs, vous devez essayer de conserver l'esprit d'origine de l'opérateur. Par exemple,
fun main(args: Array) ( val p1 = Point(3, -8) val p2 = Point(2, 9) var sum = Point() sum = p1 + p2 println("sum = ($(sum.x), $(sum.y))") ) class Point(val x: Int = 0, val y: Int = 10) ( // overloading plus function operator fun plus(p: Point) = Point(x - p.x, y - p.y) )
Bien que le programme ci-dessus soit techniquement correct, nous avons utilisé l' +opérateur pour soustraire les propriétés correspondantes de deux objets, ce qui a rendu le programme déroutant.
2. Contrairement aux langages comme Scala, seul un ensemble spécifique d'opérateurs peut être surchargé dans Kotlin. Visitez la page pour en savoir plus sur les opérateurs qui peuvent être surchargés dans Kotlin et leurs fonctions membres correspondantes.
