日本編程叢書-圖片源于網絡

在前面寫了關于集合和范圍的內容，里面包括了一點運算符重載的內容，在這里我們來詳細了解運算符重載的知識，內容參考《Kotlin實戰》（Kotlin in Action）。

什么是運算符重載？

簡單來說，就是Kotlin通過調用自己代碼中定義特定的函數名的函數（成員函數或者擴展函數），并且用operator修飾符標記，來實現特定的語言結構，例如如果你在一個類上面定義了一個特定函數命名plus的函數，那么按照Kotlin的約定，可用在這個類的實例上使用+運算符，下面是代碼。

用于重載運算符的所有函數都必須使用operator關鍵字標記。

// 一個簡單的數據類
data class Foo(val x: Int, val y: Int) {
    operator fun plus(other: Foo) : Foo = Foo(x + other.x, y + other.y)
}

fun main(args: Array<String>) {
    // 使用的時候
    val f1 = Foo(10, 20)
    val f2 = Foo(30, 40)
    // 直接用+運算符代替plus函數，事實上會調用plus函數
    println(f1 + f2) // 打印內容為Foo(x=40, y=60)
}

那么Java如何調用運算符函數呢？

重載的運算符實際上是被定義成一個函數，Java調用Kotlin運算符就跟調用普通函數一樣調用就行。

重載算術運算符

算術運算符包括二元運算符、復合賦值運算符、一元運算符，當Kotlin在給一個集合添加元素的時候，是調用add方法，用到重載的話，我們就可以直接用+=來進行這個操作，就會顯得更加的優雅。。。

fun Any.println() = println(this)

fun main(args: Array<String>) {
    val list = arrayListOf(1, 2 ,3)
    list.println() // 打印[1, 2, 3]
    list.add(4)
    list.println() // 打印[1, 2, 3, 4]
    list += 5
    list.println() // 打印[1, 2, 3, 4, 5]
}

重載二元算術運算符

二元算術運算符就是常見的+、-、*、/和取余%，優先級與數學的是一樣的，*、/和%要高于+、-的優先級。

下面我們列舉對應的函數名：

下面我們來寫個類，里面包含這幾種函數，同時還有擴展函數的定義。

fun Any.println() = println(this)

// Extension
operator fun Foo.minus(other: Foo): Foo = Foo(x - other.x, y - other.y)
operator fun Foo.div(other: Foo): Foo = Foo(x / other.x, y / other.y)

data class Foo(val x: Int, val y: Int) {
    operator fun plus(other: Foo): Foo = Foo(x + other.x, y + other.y)
    operator fun times(other: Foo): Foo = Foo(x * other.x, y * other.y)
    operator fun rem(other: Foo): Foo = Foo(x % other.x, y % other.y)
}

fun main(args: Array<String>) {
    val f1 = Foo(30, 40)
    val f2 = Foo(10, 20)
    (f1 - f2).println() // 打印Foo(x=20, y=20)
    (f1 + f2).println() // 打印Foo(x=40, y=60)
    (f1 * f2).println() // 打印Foo(x=300, y=800)
    (f1 / f2).println() // 打印Foo(x=3, y=2)
    (f1 % f2).println() // 打印Foo(x=0, y=0)
}

除了定義相同類型的運算數之外，還能定義運算數類型不同的運算符：

data class Foo(val x: Int, val y: Int) {
    operator fun times(other: Double): Foo = Foo((x * other).toInt(), (y * other).toInt())
}

fun main(args: Array<String>) {
    val f1 = Foo(30, 40)
    (f1 * 1.5).println() // 打印Foo(x=45, y=60)
}

當你通過這樣子去調用這個運算符的時候

(1.5 * f1).println()

這時候，編譯器會提示你出錯了

image

為什么會這樣呢？

image

因為Kotlin的運算符不會自動至此交換性（交換運算符的左右兩邊）。

那要怎么樣才能那樣寫呢？

image

需要定義一個單獨的運算符

operator fun Double.times(other: Foo): Foo = Foo((this * other.x).toInt(), (this * other.y).toInt())

這樣子就能直接支持運算符兩邊互換使用了。。。

(f1 * 1.5).println()
(1.5 * f1).println()

運算符函數不是單一返回類型的，也是可以定義不同的返回類型，下面舉個栗子：

operator fun Char.times(count: Int): String = toString().repeat(count)

fun main(args: Array<String>) {
    ('a' * 3).println() // 打印aaa
}

在上面的代碼中，這個運算符是Char類型的擴展函數，參數類型是Int類型，所以是Char * Int這樣的操作，返回類型是String。

注意：運算符和普通函數一樣，可以重載operator函數，可以定義多個同名，但是參數不一樣的方法。

重載復合賦值運算符

什么是復合賦值運算符？
類似于+=這樣的，合并了兩部操作的運算符，同時賦值，稱為符合運算符。

下面我們列舉對應的函數名：

fun main(args: Array<String>) {
    var f1 = Foo(1, 2)
    f1 += Foo(3, 4)
    f1.println() // 打印Foo(x=4, y=6)
}

上面的+=等同于f1 = f1 + Foo(3, 4)，這些操作當然是只對可變變量有效的。

默認情況下，復合賦值運算符是可以修改變量所引用的對象，同時重新分配引用，但是在將一個元素添加到一個可變集合的時候，+=是不會重新分配引用的：

fun main(args: Array<String>) {
    val list = mutableListOf<Int>()
    list += 42
    list.println() // 打印[42]
}

同樣我們可以對復合賦值運算符進行重載，同樣可以定義多個同名，但是參數不一樣的方法：

operator fun MutableCollection<Int>.plusAssign(element: Int) {
    this.add(element - 1)
}

fun main(args: Array<String>) {
    val list = mutableListOf<Int>()
    list += 42
    list.println() // 打印[41]
}

如果在plus和plusAssign兩個函數同時被定義且適用，那么編譯器就會報錯，最好在設計新類的時候保持（可變性）一致，盡量不同時定義plus和plusAssign運算。如Foo類是不可變的，那么只提供plus運算，如果一個類是可變的，如構造器，那么只需提供plusAssign和類似的運算就夠了。

image

實際上+=可以被轉換為plus或者plusAssign函數調用，而Kotlin的標準庫中為集合支持這兩種方法。

• +和-運算符會返回一個新的集合。
• +=和-=用于可變集合，會修改集合，如果是只讀，那么就會返回一個修改過的副本，也就是說只有在只讀集合被定義為var類型的時候，才能使用+=和-=。

fun main(args: Array<String>) {
    // 可變類型
    val list = mutableListOf<Int>(1, 2)
    // += 修改list
    list += 3
    // + 返回一個新的List
    val newList = list + listOf<Int>(4, 5) // 除了使用單個元素參數，也可使用元素類型相同的集合
    list.println() // 打印[1, 2, 3]
    newList.println() // 打印[1, 2, 3, 4, 5]
    var varList = listOf<Int>(1, 2)
    // 只讀集合類型為var
    varList.println() // 打印[1, 2]
    varList += 3
    varList.println() // 打印[1, 2, 3]
}

重載一元運算符

Kotlin中允許重載一元運算符，如-a,+a等等，同樣我們列舉支持的一元運算符和對應的函數名：

重載一元運算符過程與前面一樣，通過預先定義的一個名稱來聲明函數（成員函數或者擴展函數），并且用operator修飾符標記。

注意：一元運算符是沒有參數的。

data class Foo(val x: Int, val y: Int)

operator fun Foo.unaryMinus() = Foo(-x, -y)

fun main(args: Array<String>) {
    val f1 = Foo(1, 2)
    (-f1).println() // 打印Foo(x=-1, y=-2)
}

當重載自增自減運算符符是，編譯器自動支持前綴--a和后綴a--語義。

operator fun BigDecimal.inc() = this + BigDecimal.ONE

fun main(args: Array<String>) {
    var bd = 0
    (bd++).println() // 打印0
    (++bd).println() // 打印2
}

重載比較運算符

比較運算符，可以在除了基本數據類型外的任意對象上使用，當Java中使用equals或compareTo時，在Kotlin中，直接用運算符重載。
比較運算符分為等號運算符和排序運算符。

等號運算符equals

在我們平時使用判斷字符串是否與某個字符串相等的時候，會使用equals函數來判斷，然而在Kotlin中，我們可以是用==來代替equals函數，~=來代替!qeuals。
在Java中如果使用null對象來equals的話，會爆空指針異常，而Kotlin中的==是支持可空類型的，因為會先判斷是否為空，如a == b會先檢查a是否為空，如果不是，就會調用a.equals(b)，否則只有兩個參數都是空值，結果才為真。

image

下面我們來重載equals運算符

data class Foo(val x: Int, val y: Int) {
    override operator fun equals(other: Any?): Boolean = when {
        // 使用恒等運算符來判斷兩個參數是否同一個對象的引用
        other === this -> true
        other !is Foo -> false
        else -> other.x == x && other.y == y
    }
}

fun main(args: Array<String>) {
    val f1 = Foo(1, 2)
    val f2 = Foo(1, 2)
    val f3 = Foo(10, 20)
    (f1 == f2).println() // true
    (f1 == f2).println() // true
    (f1 != f2).println() // false
    (null == f1).println() // false
}

注意：===與Java一樣，檢查兩個參數是否是同一個對象的引用，如果是基本數據類型，檢查值是否相同，===和!==不能被重載。

排序運算符compareTo

在Java中，基本數據類型集合排序通常都是使用<和>來比較，而其他類型需要使用element1.compareTo(element2)來比較的。而在Kotlin中，通過使用比較運算符(>``<``>=``<=)來進行比較。

image

比較運算符會被轉換成compareTo函數，compareTo的返回類型必須為Int。

class Person(private val firstName: String, private val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = compareValuesBy(this, other, Person::lastName, Person::firstName)
}

fun main(args: Array<String>) {
    (Person("Alice", "Smith") < Person("Bob", "Johnson")).println() // 打印false
}

compareValuesBy函數是按順序依次調用回調方法，兩兩一組分別做比較，然后返回結果，如果則返回比較結果，如果相同，則繼續調用下一個，如果沒有更多回調來調用，則返回0。

image

override標記

Any

Comparable

從上面可以看到，equals和compareTo都是被override標記的，之所以會被標記，是因為在Any類中已經定義了equals函數，而所有的對象都默認繼承Any類，所有才重載的時候需要使用override標記，而且equals不能定義為擴展函數，因為Any類的實現是重要優先于擴展函數。
同樣，compareTo在Comparable接口中已經定義了，所有在重載的時候，需要使用override標記。