Sobrecarga de Operadores Kotlin

Neste artigo, você aprenderá sobre sobrecarga de operadores através de exemplos (como os operadores funcionam para tipos de usuário definidos (como objetos)).

Ao usar operator em Kotlin, será chamada a função membro correspondente. Por exemplo, a expressão a + b é convertida em background para a.plus(b).

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

Quando você executar o programa, a saída será:

15

Na verdade, a função plus() é sobrecarregada para lidar com vários tipos básicos de Kotlin e String (cadeia de caracteres).

//　+　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
//usado para concatenar strings
operator fun String?.plus(other: Any?): String

Você também pode definir como os operadores funcionam com objetos sobrecarregando as funções correspondentes. Por exemplo, você precisa sobrecarregar a função plus() para definir+como os operadores funcionam com objetos.

Exemplo: Sobrecarga+Operador

fun main(args: Array<String>) {
　　　　val p1　= Point(3,　-8)
　　　　val p2　= Point(2,　9)
　　　　var sum = Point()
　　　　sum = p1　+　p2
　　　　println("soma = (${sum.x}, ${sum.y})")
}
class Point(val x: Int = 0, val y: Int =　10) {
　　　　//Sobrecarga da função plus
　　　　operator fun plus(p: Point): Point
　　　　　　　　return Point(x　+　p.x, y　+　p.y)
　　　　}
}

Quando você executar o programa, a saída será:

sum = (5,　1)

Aqui, a função plus() é marcada com a palavra-chave operator, para informar o compilador + O operador está sendo sobrecarregado.

Expressão p1 + p2 é convertida em p no fundo1.plus(p2)。

Exemplo:- Sobrecarga de operadores

Neste exemplo, você aprenderá a sobrecarregar - Operador. Expressão --a é convertida em a.dec() no fundo.

a função membro dec() não possui parâmetros.

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)
}

Quando você executar o programa, a saída será:

point = (2,　-9)

Lembre-se de que

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

equivalente a

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

Atenção a alguns pontos

1ao sobrecarregar operadores, deve tentar manter o efeito original dos operadores. Por exemplo,

fun main(args: Array<String>) {
　　　　val p1　= Point(3,　-8)
　　　　val p2　= Point(2,　9)
　　　　var sum = Point()
　　　　sum = p1　+　p2
　　　　println("soma = (${sum.x}, ${sum.y})")
}
class Point(val x: Int = 0, val y: Int =　10) {
　　　　//Sobrecarregar a função plus
　　　　operator fun plus(p: Point) = Point(x　-　p.x, y　-　p.y)
}

Embora o programa acima seja tecnicamente correto, usamos + O operador subtrai os atributos correspondentes de dois objetos, o que torna o programa confuso.

2Diferente de idiomas como Scala, no Kotlin só pode sobrecarregar um conjunto específico de operadores.