Sobrecarga de operadores de Kotlin

En este artículo, aprenderás sobre la sobrecarga de operadores a través de ejemplos (cómo definen los operadores cómo funcionan para tipos definidos por el usuario (como objetos)).

Al usar operator en Kotlin, se llama a su función miembro correspondiente. Por ejemplo, la expresión a + b se convierte en a.plus(b) en segundo plano.

fun main(args: Array<String>) {
　　　　val a =　5
　　　　val b =　10
　　　　print(a.plus(b))　//　print(a+b)
}

Cuando ejecute el programa, la salida será:

15

En realidad, la función plus() se sobrecarga para manejar varios tipos básicos de Kotlin y String (cadena).

//　+　Operadores de tipos básicos
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
//para la concatenación de cadenas
operator fun String?.plus(other: Any?): String

También puede definir cómo funcionan los operadores para los objetos mediante la sobrecarga de las funciones correspondientes. Por ejemplo, necesita sobrecargar la función plus() para definir+cómo funcionan los operadores para los objetos.

Ejemplo: Sobrecarga+Operador

fun main(args: Array<String>) {
　　　　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) {
　　　　//Sobrecarga de la función plus
　　　　operator fun plus(p: Point): Point {
　　　　　　　　return Point(x　+　p.x, y　+　p.y)
　　　　}
}

Cuando ejecute el programa, la salida será:

sum = (5,　1)

Aquí, la función plus() está marcada con la palabra clave operator para informar al compilador + El operador se está sobrecargando.

Expresión p1 + p2 se convierte en el后台 p1.plus(p2)。

Ejemplo:- Sobrecarga de operadores

En este ejemplo, aprenderá a sobrecargar - Operador. Expresión --a se convierte en el后台 a.dec()。

la función miembro dec() no lleva ningún parámetro.

fun main(args: Array<String>) {
　　　　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)
}

Cuando ejecute el programa, la salida será:

point = (2,　-9)

Recuerde que,

operator fun dec() = Point(--x,　--y)

es equivalente a

operator fun dec(): Point {
　　　　return Point(--x,　--y)
}

Tenga en cuenta varios puntos

1al sobrecargar operadores, debe intentar mantener el efecto original del operador. Por ejemplo,

fun main(args: Array<String>) {
　　　　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) {
　　　　//Sobrecarga de la función plus
　　　　operator fun plus(p: Point) = Point(x　-　p.x, y　-　p.y)
}

A pesar de que el programa anterior es técnicamente correcto, usamos + El operador restituye las propiedades correspondientes de dos objetos, lo que hace que el programa se vuelva confuso.

2A diferencia de los idiomas como Scala, solo se puede sobrecargar un grupo específico de operadores en Kotlin.