En este artículo, aprenderá sobre la sobrecarga de operadores (defina cómo funciona el operador para tipos definidos por el usuario como objetos) con la ayuda de ejemplos.
Cuando usa el operador en Kotlin, se llama a la función miembro correspondiente. Por ejemplo, la expresión se a+btransforma en a.plus(b)debajo del capó.
fun main(args: Array) ( val a = 5 val b = 10 print(a.plus(b)) // print(a+b) )
Cuando ejecute el programa, la salida será:
15
De hecho, la plus()función está sobrecargada para trabajar con varios tipos básicos de Kotlin y String.
// + operador para tipos básicos operator fun plus (otro: Byte): Int operator fun plus (otro: Short): Int operator fun plus (otro: Int): Int operator fun plus (otro: Long): Long operator fun plus (otro: Float): Operador flotante fun plus (otro: Double): Double // para el operador de concatenación de cadenas fun String? .plus (other: Any?): String
También puede definir cómo funciona el operador para los objetos sobrecargando su función correspondiente. Por ejemplo, necesita definir cómo +funciona el operador para los objetos mediante la plus()función de sobrecarga .
Ejemplo: sobrecarga + operador
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) ) )
Cuando ejecute el programa, la salida será:
suma = (5, 1)
Aquí, la plus()función está marcada con una operatorpalabra clave para decirle al compilador que el +operador está sobrecargado.
La expresión p1 + p2se transforma en p1.plus(p2)debajo del capó.
Ejemplo: - Sobrecarga del operador
En este ejemplo, aprenderá a sobrecargar al --operador. La expresión --ase transforma en a.dec()debajo del capó.
La dec()función miembro no acepta argumentos.
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) )
Cuando ejecute el programa, la salida será:
punto = (2, -9)
Recuérdalo,
operador fun dec () = Punto (- x, --y)
es equivalente a
operador fun dec (): Punto (punto de retorno (- x, --y))
Pocos puntos importantes
1. Cuando sobrecargue a los operadores, debe intentar mantener el espíritu original del operador. Por ejemplo,
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) )
Aunque el programa anterior es técnicamente correcto, hemos usado el +operador para restar las propiedades correspondientes de dos objetos que hicieron que el programa fuera confuso.
2. A diferencia de lenguajes como Scala, en Kotlin solo se puede sobrecargar un conjunto específico de operadores. Visite la página para obtener información sobre los operadores que pueden sobrecargarse en Kotlin y sus funciones de miembro correspondientes.
