日本編程叢書-圖片源于網(wǎng)絡(luò)

在前面寫了關(guān)于集合和范圍的內(nèi)容，里面包括了一點(diǎn)運(yùn)算符重載的內(nèi)容，在這里我們來(lái)詳細(xì)了解運(yùn)算符重載的知識(shí)，內(nèi)容參考《Kotlin實(shí)戰(zhàn)》（Kotlin in Action）。

什么是運(yùn)算符重載？

簡(jiǎn)單來(lái)說(shuō)，就是Kotlin通過(guò)調(diào)用自己代碼中定義特定的函數(shù)名的函數(shù)（成員函數(shù)或者擴(kuò)展函數(shù)），并且用operator修飾符標(biāo)記，來(lái)實(shí)現(xiàn)特定的語(yǔ)言結(jié)構(gòu)，例如如果你在一個(gè)類上面定義了一個(gè)特定函數(shù)命名plus的函數(shù)，那么按照Kotlin的約定，可用在這個(gè)類的實(shí)例上使用+運(yùn)算符，下面是代碼。

用于重載運(yùn)算符的所有函數(shù)都必須使用operator關(guān)鍵字標(biāo)記。

// 一個(gè)簡(jiǎn)單的數(shù)據(jù)類
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>) {
    // 使用的時(shí)候
    val f1 = Foo(10, 20)
    val f2 = Foo(30, 40)
    // 直接用+運(yùn)算符代替plus函數(shù)，事實(shí)上會(huì)調(diào)用plus函數(shù)
    println(f1 + f2) // 打印內(nèi)容為Foo(x=40, y=60)
}

那么Java如何調(diào)用運(yùn)算符函數(shù)呢？

重載的運(yùn)算符實(shí)際上是被定義成一個(gè)函數(shù)，Java調(diào)用Kotlin運(yùn)算符就跟調(diào)用普通函數(shù)一樣調(diào)用就行。

重載算術(shù)運(yùn)算符

算術(shù)運(yùn)算符包括二元運(yùn)算符、復(fù)合賦值運(yùn)算符、一元運(yùn)算符，當(dāng)Kotlin在給一個(gè)集合添加元素的時(shí)候，是調(diào)用add方法，用到重載的話，我們就可以直接用+=來(lái)進(jìn)行這個(gè)操作，就會(huì)顯得更加的優(yōu)雅。。。

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

重載二元算術(shù)運(yùn)算符

二元算術(shù)運(yùn)算符就是常見(jiàn)的+、-、*、/和取余%，優(yōu)先級(jí)與數(shù)學(xué)的是一樣的，*、/和%要高于+、-的優(yōu)先級(jí)。

下面我們列舉對(duì)應(yīng)的函數(shù)名：

下面我們來(lái)寫個(gè)類，里面包含這幾種函數(shù)，同時(shí)還有擴(kuò)展函數(shù)的定義。

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

除了定義相同類型的運(yùn)算數(shù)之外，還能定義運(yùn)算數(shù)類型不同的運(yùn)算符：

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

當(dāng)你通過(guò)這樣子去調(diào)用這個(gè)運(yùn)算符的時(shí)候

(1.5 * f1).println()

這時(shí)候，編譯器會(huì)提示你出錯(cuò)了

image

為什么會(huì)這樣呢？

image

因?yàn)镵otlin的運(yùn)算符不會(huì)自動(dòng)至此交換性（交換運(yùn)算符的左右兩邊）。

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

image

需要定義一個(gè)單獨(dú)的運(yùn)算符

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

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

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

運(yùn)算符函數(shù)不是單一返回類型的，也是可以定義不同的返回類型，下面舉個(gè)栗子：

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

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

在上面的代碼中，這個(gè)運(yùn)算符是Char類型的擴(kuò)展函數(shù)，參數(shù)類型是Int類型，所以是Char * Int這樣的操作，返回類型是String。

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

重載復(fù)合賦值運(yùn)算符

什么是復(fù)合賦值運(yùn)算符？
類似于+=這樣的，合并了兩部操作的運(yùn)算符，同時(shí)賦值，稱為符合運(yùn)算符。

下面我們列舉對(duì)應(yīng)的函數(shù)名：

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)，這些操作當(dāng)然是只對(duì)可變變量有效的。

默認(rèn)情況下，復(fù)合賦值運(yùn)算符是可以修改變量所引用的對(duì)象，同時(shí)重新分配引用，但是在將一個(gè)元素添加到一個(gè)可變集合的時(shí)候，+=是不會(huì)重新分配引用的：

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

同樣我們可以對(duì)復(fù)合賦值運(yùn)算符進(jìn)行重載，同樣可以定義多個(gè)同名，但是參數(shù)不一樣的方法：

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兩個(gè)函數(shù)同時(shí)被定義且適用，那么編譯器就會(huì)報(bào)錯(cuò)，最好在設(shè)計(jì)新類的時(shí)候保持（可變性）一致，盡量不同時(shí)定義plus和plusAssign運(yùn)算。如Foo類是不可變的，那么只提供plus運(yùn)算，如果一個(gè)類是可變的，如構(gòu)造器，那么只需提供plusAssign和類似的運(yùn)算就夠了。

image

實(shí)際上+=可以被轉(zhuǎn)換為plus或者plusAssign函數(shù)調(diào)用，而Kotlin的標(biāo)準(zhǔn)庫(kù)中為集合支持這兩種方法。

• +和-運(yùn)算符會(huì)返回一個(gè)新的集合。
• +=和-=用于可變集合，會(huì)修改集合，如果是只讀，那么就會(huì)返回一個(gè)修改過(guò)的副本，也就是說(shuō)只有在只讀集合被定義為var類型的時(shí)候，才能使用+=和-=。

fun main(args: Array<String>) {
    // 可變類型
    val list = mutableListOf<Int>(1, 2)
    // += 修改list
    list += 3
    // + 返回一個(gè)新的List
    val newList = list + listOf<Int>(4, 5) // 除了使用單個(gè)元素參數(shù)，也可使用元素類型相同的集合
    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]
}

重載一元運(yùn)算符

Kotlin中允許重載一元運(yùn)算符，如-a,+a等等，同樣我們列舉支持的一元運(yùn)算符和對(duì)應(yīng)的函數(shù)名：

重載一元運(yùn)算符過(guò)程與前面一樣，通過(guò)預(yù)先定義的一個(gè)名稱來(lái)聲明函數(shù)（成員函數(shù)或者擴(kuò)展函數(shù)），并且用operator修飾符標(biāo)記。

注意：一元運(yùn)算符是沒(méi)有參數(shù)的。

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

當(dāng)重載自增自減運(yùn)算符符是，編譯器自動(dòng)支持前綴--a和后綴a--語(yǔ)義。

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

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

重載比較運(yùn)算符

比較運(yùn)算符，可以在除了基本數(shù)據(jù)類型外的任意對(duì)象上使用，當(dāng)Java中使用equals或compareTo時(shí)，在Kotlin中，直接用運(yùn)算符重載。
比較運(yùn)算符分為等號(hào)運(yùn)算符和排序運(yùn)算符。

等號(hào)運(yùn)算符equals

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

image

下面我們來(lái)重載equals運(yùn)算符

data class Foo(val x: Int, val y: Int) {
    override operator fun equals(other: Any?): Boolean = when {
        // 使用恒等運(yùn)算符來(lái)判斷兩個(gè)參數(shù)是否同一個(gè)對(duì)象的引用
        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一樣，檢查兩個(gè)參數(shù)是否是同一個(gè)對(duì)象的引用，如果是基本數(shù)據(jù)類型，檢查值是否相同，===和!==不能被重載。

排序運(yùn)算符compareTo

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

image

比較運(yùn)算符會(huì)被轉(zhuǎn)換成compareTo函數(shù)，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函數(shù)是按順序依次調(diào)用回調(diào)方法，兩兩一組分別做比較，然后返回結(jié)果，如果則返回比較結(jié)果，如果相同，則繼續(xù)調(diào)用下一個(gè)，如果沒(méi)有更多回調(diào)來(lái)調(diào)用，則返回0。

image

override標(biāo)記

Any

Comparable

從上面可以看到，equals和compareTo都是被override標(biāo)記的，之所以會(huì)被標(biāo)記，是因?yàn)樵?code>Any類中已經(jīng)定義了equals函數(shù)，而所有的對(duì)象都默認(rèn)繼承Any類，所有才重載的時(shí)候需要使用override標(biāo)記，而且equals不能定義為擴(kuò)展函數(shù)，因?yàn)?code>Any類的實(shí)現(xiàn)是重要優(yōu)先于擴(kuò)展函數(shù)。
同樣，compareTo在Comparable接口中已經(jīng)定義了，所有在重載的時(shí)候，需要使用override標(biāo)記。