Sovraccarico degli operatori in Kotlin

In questo articolo, imparerai riguardo al sovraccarico degli operatori tramite esempi (come gli operatori funzionano per tipi definiti dall'utente come oggetti).

Quando si utilizza operator in Kotlin, viene chiamata la sua funzione membro corrispondente. Ad esempio, l'espressione a + b viene convertita in background in a.plus(b).

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

Quando esegui il programma, l'output sarà:

15

In realtà, la funzione plus() è sovraccaricata per gestire vari tipi di base di Kotlin e Stringhe (stringhe).

// + operatore di calcolo per tipi di base
operatore fun plus(other: Byte): Int
operatore 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
//Usato per la connessione di stringhe
operator fun String?.plus(other: Any?): String

Puoi anche definire come gli operatori lavorano con gli oggetti sovraccaricando le funzioni corrispondenti. Ad esempio, devi sovraccaricare la funzione plus() per definire come l'operatore + lavora con gli oggetti.

Esempio: sovraccarico dell'operatore +

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

Quando esegui il programma, l'output sarà:

sum = (5, 1)

In questo caso, la funzione plus() è marcata con la parola chiave operator per informare il compilatore che l'operatore + viene sovraccaricato.

L'espressione p1 + p2 viene convertita in background in p1.plus(p2).

Esempio: sovraccarico dell'operatore -

In questo esempio, imparerai a sovraccaricare l'operatore -.

La funzione membro dec() non accetta alcun parametro.

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 esegui il programma, l'output sarà:

point = (2, -9)

Ricorda,

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

è equivalente a

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

Attenzione a alcuni punti chiave

1、Sul caricamento degli operatori, è consigliabile mantenere l'effetto originale dell'operatore. Ad esempio,

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

Nonostante il programma sopra sia tecnicamente corretto, abbiamo utilizzato l'operatore + per sottrarre le proprietà corrispondenti di due oggetti, il che rende il programma confuso.

A differenza di linguaggi come Scala, in Kotlin è possibile sovraccaricare solo un insieme specifico di operatori.