Kotlin教程（七）運算子過載及其他約定

寫在開頭：本人打算開始寫一個Kotlin系列的教程，一是使自己記憶和理解的更加深刻，二是可以分享給同樣想學習Kotlin的同學。系列文章的知識點會以《Kotlin實戰》這本書中順序編寫，在將書中知識點展示出來同時，我也會新增對應的Java程式碼用於對比學習和更好的理解。

Kotlin教程（一）基礎
Kotlin教程（二）函式
Kotlin教程（三）類、物件和介面
Kotlin教程（四）可空性
Kotlin教程（五）型別
Kotlin教程（六）Lambda程式設計
Kotlin教程（七）運算子過載及其他約定
Kotlin教程（八）高階函式
Kotlin教程（九）泛型

---

如你所知，Java在標準庫中有一些與特定的類相關聯的語言特性。例如，實現了java.lang.Iterable介面的獨享可以在for迴圈中使用，實現了java.lang.AutoCloseable介面的物件可以在try-with-resources語句中使用。
Kotlin也有許多特性的原理非常類似，通過呼叫自己程式碼中定義的函式，來實現特定語言結構。但是，在Kotlin中，這些功能與特定的函式命名相關，而不是與特定的型別繫結。

這一章我們會用到一個UI框架中常見的類Point來演示，來看下定義：

data class Ponit(val x: Int, val y: Int)
複製程式碼

過載算術運算子

在Java中，全套的算數運算只能用於基本資料型別，+運算子可以與String值一起使用。但是，這些運算子在其他一些情況下用起來也很方便。例如，在使用哪個BigInteger類處理數字的時候，使用+號就比掉用add方法顯得更為優雅：給集合新增元素的時候，你可能也在想要是能用+=運算子就好了，在Kotlin中，你就可以這樣做。

過載二元算術運算

我們來支援第一個運算，把兩個點加到一起：

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}
>>> val p1 = Point(10, 20)
>>> val p2 = Point(30, 40)
>>> println(p1 + p2)
Point(x=40, y=60)
複製程式碼

用於過載運算子的所有函式都需要使用operator關鍵字標記，表示你把這個函式作為相應的約定的實現，並且不是碰巧地定義了同名函式。
使用operator修飾符宣告plus函式之後，你就可以直接使用+號來求和了。實際上呼叫的時plus函式a + b -> a.plus(b)。 除了宣告成為一個成員函式外，也可以定義為一個擴充套件函式，同樣有效：

operator fun Point.plus(other: Point): Point {
    return Point(x + other.x, y + other.y)
}
複製程式碼

Kotlin中可過載的二元算術運算子

表示式	函式名
a * b	times
a / b	div
a % b	mod
a + b	plus
a - b	minus

自定義型別的運算子，基本上和與標準數字型別的運算子有著相同的優先順序。例如a + b * c，乘法將之中在加號之前執行。運算子*、 /和%具有相同的優先順序，高於+和-運算子的優先順序。

運算子函式和Java

從Java呼叫Kotlin運算子非常容易：因為每個過載的運算子都被定義為一個函式，可以像普通函式那樣呼叫它們。當從Kotlin呼叫Java的時候，只要Java程式碼中存在函式名和引數數量都匹配的函式，就可以在Kotlin中使用。如果Java已經存在類似的方法，但是方法名不同，可以通過擴充套件函式來修正這個函式名，用來代替現有的Java方法。

當你定義一個運算子的時候，不要求兩個運算數是相同的型別，例如，讓我們定義一個運算子，它允許你用一個數字來縮放一個點，可以用它在不同座標系之間做轉換：

operator fun Point.times(scale: Double): Point {
    return Point((x * scale).toInt(), (y * scale).toInt())
}
>>> val p1 = Point(10, 20)
>>> println(p1 * 1.5)
Point(x=15, y=30)
複製程式碼

注意，Kotlin運算子不會自動支援交換性（交換運算子的左右兩邊）。如果希望使用者能夠使用p * 1.5以外，還能使用1.5 * p，你需要為它定義一個單獨的運算子operator fun Double.times(p: Point) : Point。

運算子函式的返回型別可以不同於任一運算數型別，例如，可以定義一個運算子，通過多次重複單個字元來建立字串：

operator fun Char.times(count: Int): String {
    return toString().repeat(count)
}
>>> println('a' * 3)
aaa
複製程式碼

這個運算子接收一個Char作為左值，Int作為右值，然後返回一個String型別。

和普通的函式一樣，可以過載operator函式：可以定義多個同名的，但引數型別不同的方法。

沒有用於位運算的特殊運算子

Kotlin沒有為標準數字型別定義任何位運算子。因此，也不允許你為自定義型別定義它們，相反，它使用支援中綴呼叫語法的常規函式，可以為自定義型別定義相似的函式。
以下是Kotlin提供的，用於執行位運算的完整函式列表：

• shl ——帶符號左移，等同Java中<<
• shr ——帶符號右移，等同Java中>>
• ushr ——無符號右移，等同Java中<<<
• and ——按位與，等同Java中&
• or ——按位或，等同Java中|
• xor ——按位異或，等同Java中^
• inv ——按位取反，等同Java中~

過載複合賦值運算子

通常情況下，當你在定義想plus這樣的運算子函式時，Kotlin不止支援+號運算，也支援+=。像+=，-=等這些運算子被稱為複合賦值運算子。看這個例子：

>>> var p1 = Point(10, 20)
>>> p1 += Point(30, 40)
>>> println(p1)
Point(x=40, y=60)
複製程式碼

這等用於point = point + Point(30, 40) 的寫法。當然，這個只對於可變變數有效。
在一些情況下，定義+=運算子可以修改使用它的變數所引用的物件，但不會重新分配引用，將一個元素新增到可變集合，就是一個很好的例子：

>>> val numbers = ArrayList<Int>()
>>> numbers += 42
>>> println(numbers)
42
複製程式碼

如果你定義了一個返回值為Unit，名為plusAssign的函式，Kotlin將會在用到+=運算子的地方呼叫它，其他二元算術運算子也有命名相似的對應函式：如minusAssign、timeAssign等。
Kotlin標準庫為可變集合定義了plusAssign函式,我們才能像例子中那樣使用+=：

operator fun <T> MutableCollection<T> plusAssgin(element: T) {
    this.add(element)
}
複製程式碼

當你在程式碼中用到+=的時候，理論上plus和plusAssign都可能被呼叫。如果在這種情況下，兩個函式都有定義且使用，編譯器會報錯！一種辦法是直接使用普通函式的呼叫方式呼叫，另一種辦法是用val代替var，這樣plusAssign運算就不在適用。但是更建議只定義一種運算函式，plus通常定義返回一個新物件，而plusAssign返回的是之前的物件，根據這個原則選擇合適的運算函式定義即可。

Kotlin標準庫支援集合的這兩種方法。+和-運算子總是返回一個新的集合。+=和-=運算子用於可變集合時，始終就地修改它們：而它們用於只讀集合時，或返回一個修改過的副本（這意味著只有當引用只讀集合的變數被宣告為var的時候，才能使用+=和-=）。作為它們的運算數，可以使用單個元素，也可以使用元素型別一致的其他集合：

>>> val list = arrayListOf(1, 2)
>>> list += 3
>>> val newList = list + listOf(4, 5) //返回一個新集合
>>> println(list)
[1, 2, 3]
>>> println(newList)
[1, 2, 3, 4, 5]
複製程式碼

過載一元運算子

過載一元運算子的過程與你在前面看到的方式相同：用預先定義的一個名稱來宣告（成員函式或擴充套件函式），並用修飾符operator標記。我們來看一個例子：

operator fun Point.unaryMinus(): Point = Point(-x, -y)

>>> val p = Point(10, 20)
>>>println(-p)
Point(x=-10, y=-20)
複製程式碼

用於過載一元運算子的函式，沒有任何引數。

可過載的一元演算法的運算子

表示式	函式名
+a	unaryPlus
-a	unaryMinus
!a	not
++a, a++	inc
--a, a--	dec

當你定義inc和dec函式來過載自增和自減的運算子時，編譯器自動支援與普通數字型別的字首和字尾自增運算子相同的語義。考慮一下用來過載BigDecimal類的++運算子的這個例子：

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

>>> var bd = BigDecimal.ZERO
>>> println(bd++)
0
>>> println(++bd)
2
複製程式碼

字尾運算++首先返回bd變數的當前值，然後執行++，這個和字首運算相反。列印多的值與使用Int型別的變數所看到的相同，不需要額外做什麼特別的事情就能支援。

過載比較運算子

與算術運算子一樣，在Kotlin中，可以對任何物件使用比較運算子（==、!=、>、<等），而不僅僅限於基本資料型別。不用像Java那樣呼叫equals或compareTo函式，可以直接使用比較運算子。

等號運算子：equals

我們在教程三中就說到，Kotlin中使用==運算子，它將被轉換成equals方法的呼叫。
使用!=運算子也會被轉換成equals函式的呼叫，明顯的差異在於，它們的結果是相反的，和所有其他運算子不同的是：==和!=可以用於可空運算數，因為這些運算子事實上會檢查運算數是否為null。比較 a == b 會檢查a是否為非空，如果不是，就呼叫a.equals(b) 否則，只有兩個引數都是空引用，結果才是true。

a == b -> a?.equals(b) ?: (b == null)

對於Point類，因為已經被標記為資料類，equals的實現將會由編譯器自動生成。但如果手動實現，name程式碼可以是這樣的：

data class Point(val x: Int, val y: Int) {
    override fun equals(other: Any?): Boolean {
        if (other === this) return true
        if (other !is Point) return false
        return other.x == x && other.y == y
    }
}
>>> println(Point(10, 20) == Point(10, 20))
true
>>>  println(Point(10, 20) != Point(5, 5))
true
>>>  println(null == Point(10, 20))
false
複製程式碼

這裡使用了恆等運算子（===）來檢查引數與呼叫equals的物件是否相同。恆等運算子與Java中的==運算子完全相同：檢查兩個引數是否是同一個物件的引用（如果是基本資料型別，檢查他們是否是相同的值）。在實現了equals方法之後，通常會使用這個運算子來優化呼叫程式碼。注意，===運算子不能被過載。
equals函式之所以被標記override，那是因為與其他約定不同的是，這個方法的實現是在Any類中定義的、這也解釋了為什麼你不需要將它標記為operator，Any中的基本方法就已經標記了，而且函式的operator修飾符也適用於所有實現或重寫它的方法。還要注意，equals不能實現為擴充套件方法，因為繼承自Any類的實現始終優先於擴充套件函式。
這個例子顯示!=運算子的使用也會轉換為equals方法的呼叫，編譯器會自定對返回值取反，因此，你不需要再做別的事情，就可以正常執行。

排序運算子：compareTo

在java中，類可以實現Comparable介面，以便在比較值的演算法中使用，例如在查詢最大值或排序的時候。介面中定義的compareTo方法用於確定一個物件是否大於另一個物件。但在Java中，這個方法的呼叫沒有簡明語法，只有基本資料型別能使用<和>來比較，所有其他型別都需要明確寫為element1.conpareTo(element2)。
Kotlin支援相同的Comparable介面。但是可口中定義的compareTo方法可以按約定呼叫，比較運算子（>,<,<=和>=）的使用將被轉換為compareTo，compareTo的返回型別必須為Int。p1 < p2 表示式等價於 p1.compareTo(p2) < 0。其他比較運算子的運算方式也是完全一樣的。 我們假設以Point在y軸上的位置來確定大小，y越大則Point越大：

data class Point(val x: Int, val y: Int) : Comparable<Point> {
    override fun compareTo(other: Point): Int {
        return y.compareTo(other.y)
    }
}

>>> val p1 = Point(10, 20)
>>> val p2  = Point(30, 40)
>>> val p3  = Point(30, 10)
>>> println(p1 < p2)
true
>>> println(p1 < p3)
false
複製程式碼

我們通過實現Comparable介面的方式過載compareTo方法，這樣做還可以被Java函式（比如用於對集合進行排序的功能）進行比較，與equals一樣，operator修飾符已經被用在了基類的介面中，因此在重寫該介面時無需在重複。
所有Java中實現了Comparable介面的類，都可以在Kotlin中使用簡潔的運算子語法，不用再增加擴充套件函式：

>>> println("abc" > "bac")
true
複製程式碼

集合與區間的終定

通過下標來訪問元素：get和set

我們已經知道在Kotlin中可以用類似Java中陣列的方式來訪問map中的元素：

val value = map[key]
複製程式碼

也可以用同樣的運算子來改變一個可變map的元素：

mutableMap[key] = newValue
複製程式碼

來看看它是如何工作的。在Kotlin中，下標運算子是一個約定。使用下標運算子讀取元素會被轉換為get運算子方法的呼叫，並且寫入元素將呼叫set。Map和MutableMap的介面已經定義了這些方法。讓我們看看如何給自定義的類新增類似的方法。
可以使用方括號來引用點的座標，p[0]訪問x座標， p[1]訪問y座標：

operator fun Point.get(index: Int): Int {
    return when (index) {
        0 -> x
        1 -> y
        else -> throw IndexOutOfBoundsException("Invalid coordinate $index")
    }
}
>>> val p = Point(10, 20)
>>> println(p[1])
20
複製程式碼

你只需要定義一個名為get的函式，並標記operator之後，像p[1]這樣的表示式，其中p具有型別Point，將被轉換為get方法的呼叫。
x[a, b] -> x.get(a ,b)

get的引數可以是任何型別，而不只是Int。例如，當你對map使用下標運算子時，引數型別是鍵的型別，它可以是任意型別。還可以定義具有多個引數的get方法。例如，如果要實現一個類來表示二維陣列或矩陣，你可以定義一個方法，例如operator fun get(rowIndex: Int, colIndex: Int) ，然後用matrix[row, col] 來呼叫。如果需要使用不同的鍵型別訪問集合，也可以使用不同的引數型別定義多個過載的get方法。
我們也可以用類似的方法定義一個函式，這樣就可以使用方括號語法更改給定下標處的值。Point類是不可變的，所以定義Point的這種方法是沒有意義的。作為例子，我們來定義另一個類來表示一個可變的點：

data class MutablePoint(var x: Int, var y: Int)

operator fun MutablePoint.set(index: Int, value: Int) {
    when (index) {
        0 -> x = value
        1 -> y = value
        else -> throw IndexOutOfBoundsException("Invalid coordinate $index")
    }
}
>>> val p = MutablePoint(10, 20)
>>> p[1] = 42
>>> println(p)
MutablePoint(x=10, y=42)
複製程式碼

這個例子也很簡單，只需定義一個名為set的函式，就可以在賦值語句中使用下標運算子。set的最後一個引數用來接收賦值語句中等號右邊的值，其他引數作為方括號內的下標。
x[a ,b] = c -> x.set(a, b, c)

in 的約定

集合支援的另一個運算子是in運算子，用於檢查某個物件是否屬於集合。相應的函式叫做contains。我們來實現以下，使用in運算子來檢查點是否屬於一個矩形：

operator fun Rectangle.contains(p: Point): Boolean {
    return p.x in upperLeft.x until lowerRight.x
            && p.y in upperLeft.y until lowerRight.y
}
>>> val rect = Rectangle(Point(10, 20), Point(50, 50))
>>> println(Point(20, 30) in rect)
true
>>> println(Point(5, 5) in rect)
false
複製程式碼

in右邊的物件將會呼叫contains函式，in左邊的物件將會作為函式入參。
a in c -> c.contains(a)

在Rectangle.contains的實現中，我們用到了的標準庫的until函式，來構建一個開區間，然後使用運算子in來檢查某個點是否屬於這個區間。
開區間是不包含最後一個點的區間。例如，如果用10..20構建一個普通的區間（閉區間），該區間則包括10到20的所有數字，包括20。開區間10 until 20 包括從10到19的數字，但不包括20。矩形類通常定義成這樣，它的底部和右側座標不是矩形的一部分，因此在這裡使用開區間是合適的。

rangeTo的約定

要建立一個區間，請使用..語法。..運算子是呼叫rangeTo函式的一個簡潔方法。
start..end -> start.rangeTo(end)

rangeTo函式返回一個區間。你可以為自己的類定義這個運算子。但是，如果該類實現了Comparable介面，那麼就不需要了：你可以通過Kotlin標準庫建立一個任意可比較元素的區間，這個庫定義了可以用於任何可比較元素的rangeTo函式：

operator fun <T: Comparable<T>> T.rangeTo(that: T): ClosedRange<T>
複製程式碼

這個函式返回一個區間，可以用來檢測其他一些元素是否屬於它。

rangeTo運算子的優先順序低於算術運算子，但是最好把引數括起來以免混淆：

>>> val n = 9
>>> println(0..(n + 1))
0..10
複製程式碼

還要注意，表示式0..n.forEach{}不會被編譯，必須把區間表示式括起來才能呼叫它的方法：

>>> (0..n).forEach { print(it) }
0123456789
複製程式碼

在for迴圈中使用iterator的約定

在Kotlin中，for迴圈中也可以使用in運算子，和做區間檢查一樣。但是在這種情況下它的含義是不同的：它被用來執行迭代。這意味著一個諸如for(x in list) {}將被轉換成list.iterator() 的呼叫，然後就像在Java中一樣，在它上面重複呼叫hasNext和next方法。
在Kotlin中，這也是一種約定，這意味著iterator方法可以被定義為擴充套件函式。這就解釋了為什麼可以遍歷一個常規的Java字串：標準庫已經為CharSequence定義了一個擴充套件函式iterator，而它是String的父類：

public operator fun CharSequence.iterator(): CharIterator = object : CharIterator() {
    private var index = 0

    public override fun nextChar(): Char = get(index++)

    public override fun hasNext(): Boolean = index < length
}

>>> for (c in "abc") {}
複製程式碼

解構宣告和元件函式

解構宣告允許你展開單個複合值，並使用它來初始化多個單獨的變數。來看看它是怎樣工作的：

>>> val p = Point(10, 20)
>>> val (x, y) = p
>>> println(x)
10
>>> println(y)
20
複製程式碼

一個解構宣告看起來像一個普通的變數宣告，但它在括號中有多個變數。
事實上，解構宣告再次用到了約定的原理。要在結構宣告中初始化每個變數，將呼叫名為componentN的函式，其中N是宣告中變數的位置。換句話說，前面的例子可以被轉換成：
val (a, b) = p -> val a = p.component1(); val b = p.component2()
對於資料類，編譯器為每個在主構造方法中宣告的屬性生成一個componentN函式。下面的例子顯示瞭如何手動為非資料類宣告這些功能：

class Point(val x: Int,val y: Int) {
    operator fun component1() = x
    operator fun component2() = y
}
複製程式碼

解構宣告主要使用場景之一，是從一個函式返回多個值，這個非常有用。如果要這樣做，可以定義一個資料類來儲存返回所需的值，並將它作為函式的返回型別。在呼叫函式後，可以用解構宣告的方式，來輕鬆地展開它，使用其中的值。舉個例子，讓我們編寫一個簡單的函式，來將一個檔名分割成名字和副檔名：

data class NameComponents(val name: String, val extension: String)

fun splitFilename(fullName: String): NameComponents {
    val (name, extension) = fullName.split('.', limit = 2)
    return NameComponents(name, extension)
}

>>> val (name, ext) = splitFilename("example.kt")
>>> println(name)
example
>>> println(ext)
kt
複製程式碼

當然，不可能定義無線數量的componentN函式，這樣這個語法就可以與任意數量的集合一起工作了，但這也沒用。標準庫只允許使用此語法來訪問一個物件的前五個元素。
讓一個函式能返回多個值有更簡單的方法，是使用標準庫中的Pair和Triple類，在語義表達上這種方式會差一點，因為這些類也不知道它會返回的物件中包含什麼，但因為不需要定義自己的類所以可以少寫程式碼。

解構宣告和迴圈

解構宣告不僅可以作用函式中的頂層語句，還可以用在其他可以宣告變數的地方，例如in迴圈。一個很好的例子，是列舉map中的條目，下面是一個小例子：

fun printEntries(mapL Map<String, String>) {
    for ((key, value) in map){
        println("$key -> $value")
    }
}

>>> val map = mapOf("Oracle" to "Java", "JetBrans" to "Kotlin")
>>> printEntries(map)
Oracle -> Java
JetBrans -> Kotlin
複製程式碼

這個簡單的例子用到了兩個Kotlin的約定：一個是迭代一個物件，另一個是用於解構宣告。Kotlin標準庫給map增加了一個擴充套件的iterator函式，用來返回Entry條目的迭代器。因此，與Java不同的是，可以直接迭代map。它還包含Map.Entry上的擴充套件函式component1和component2，分別返回它的鍵和值。實際上，前面的迴圈被轉換成了這樣的程式碼：

for (entry in map.entries){
    val key = entry.component1()
    val value = entry.component2()
    //...
}
複製程式碼

重用屬性訪問的邏輯：委託屬性

委託屬性的基本操作

委託屬性的基本語法時這樣的：

class Foo {
    var p: Type by Delegate()
}
複製程式碼

屬性p將它的訪問器邏輯委託給了另一個物件：這裡是Delegate類的一個新例項。通過關鍵字by對其後的表示式求值來獲取這個物件，關鍵字by可以用於任何符合屬性委託約定規則的物件。
編譯器建立一個隱藏的輔助屬性，並使用委託物件的例項進行初始化，初始屬性p會委託給該例項。為了簡單起見，我們把它稱為delegate：

class Foo {
    private val delegate = Delegate() //編譯器自動生成
    var p: Type //p的訪問交給delegate
        set(value: Type) = delegate.setValue(..., value)
        get() = delegate.getValue(...)
}

複製程式碼

按照約定，Delegate類必須具有getValue和setValue方法（後者僅適用於可變屬性）。它們可以是成員函式，也可以是擴充套件函式。為了讓例子看起來更簡潔，這裡我們省略掉引數。準確的函式簽名將在之後接招。Delegate類的簡單實現差不多應該是這樣的：

class Delegate{
    operator fun getValue(...) {...}  //實現getter邏輯
    operator fun setValue(..., value: Type) {...} //實現setter邏輯
}

class Foo{
    var p: Type by Delegate() //屬性關聯委託物件
}

>>> val foo = Foo()
>>> val oldValue = foo.p
>>> foo.p = newValue
複製程式碼

可以把foo.p作為普通的屬性使用，事實上，它將呼叫Delegate型別的輔助屬性的方法。為了研究這種機制如何在實踐中使用，我們首先看一個委託屬性展示威力的例子：庫對惰性初始化的支援。

使用委託屬性：惰性初始化和 by lazy()

惰性初始化是一種常見的模式，知道在第一次訪問該屬性的時候，才根據需要建立物件的一部分。當初始化過程消耗大量資源並且在使用物件時並不總是需要資料時，這個非常有用。
舉個例子，一個Person類，可以用來訪問一個人寫的郵件列表。郵件儲存在資料庫中，訪問比較耗時。你希望只有在首次訪問時才載入郵件，並只執行一次。假設你已經有函式loadEmails，用來從資料庫中檢索電子郵件：

class Email {/*...*/}
fun loadEmail(person: Person): List<Email> {
    println("Load emails for ${person.name}")
    return listOf(/*...*/)
}
複製程式碼

下面展示如何使用額外的_emails屬性來實現惰性載入，在沒有載入之前為null，然後載入為郵件列表：

class Person(val name: String) {
    private var _emails: List<Email>? = null
    val emails: List<Email>
        get() {
            if(_emails == null) {
                _emails = loadEmails(this)
            }
            return _emials!!
        }
}
>>> val p = Person("Alice")
>>> p.emails   //第一次載入會訪問郵件
Load emails for Alice
>>> p.emails
複製程式碼

這裡使用了所謂的屬性支援。你有一個屬性_emails來儲存這個值，而另一個emails，用來提供對屬性的讀取訪問。你需要使用兩個屬性，因為屬性具有不同型別：_emails可空，而emails為非空。這種技術經常會使用到，值得熟練掌握。
但這個程式碼有點囉嗦：要是有幾個惰性屬性那得有多長。而且，它並不總是正常執行：這個實現不是執行緒安全的。Kotlin提供了更好的解決方案。
使用委託屬性會讓程式碼變得簡單得多，可以封裝用於儲存值得支援屬性和確保該值只被初始化一次的邏輯。在這裡可以使用標準庫函式lazy放回的委託。

class Person(val name: String) {
    val emails by lazy { loadEmails(this) }
}
複製程式碼

lazy函式返回一個物件，該物件具有一個名為getValue且簽名正確的方法，因此可以把它與by關鍵字一起使用來建立一個委託屬性。lazy的引數是一個lambda，可以呼叫它來初始化這個值。預設情況下，lazy函式是執行緒安全的，如果需要，可以設定其他選項來告訴它要使用哪個鎖，或者完全避開同步，如果該類永遠不會再多執行緒中使用。

實現委託屬性

要了解委託屬性的實現方式，讓我們來看另一個例子：當一個物件的屬性更改時通知監聽器。這在許多不同的情況下都很有用：例如，當物件顯示在UI時，你希望在物件變化時UI能自動重新整理。Java具有用於此類通知的標準機制：PropertyChangeSupport和PropertyChangeEvent類。讓我們看看在Kotlin中不使用委託屬性的情況下，該如何使用它們，然後我們再將程式碼重構為用委託屬性的方式。
PropertyChangeSupport類維護了一個監聽器列表，並向它們傳送PropertyChangeEvent事件。要使用它，你通常需要把這個類的一個例項儲存為bean類的一個欄位，並將屬性更改的處理委託給它。
為了避免要在每個類中新增這個欄位，你需要建立一個小的工具類，用來儲存PropertyChangeSupport的例項並監聽屬性更改。之後，你的類會繼承這個工具類，以訪問changeSupport。

open class PropertyChangeAware {
    protected val changeSupport = PropertyChangeSupport(this)

    fun addPropertyChangeListener(listener: PropertyChangeListener) {
        changeSupport.addPropertyChangeListener(listener)
    }

    fun removePropertyChangeListener(listener: PropertyChangeListener) {
        changeSupport.removePropertyChangeListener(listener)
    }
}
複製程式碼

現在我們來寫一個Person類，定義一個只讀屬性（作為一個人的名字，一般不會隨時更改）和兩個可寫屬性：年齡和工資。當這個人的年齡或工資發生變化時，這個類將通知它的監聽器。

class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
    var age: Int = age
        set(newValue) {
            val oldValue = field  //field識別符號訪問支援欄位
            field = newValue
            changeSupport.firePropertyChange("age", oldValue, newValue)  //屬性變化時通知監聽器
        }

    var salary: Int = salary
        set(newValue) {
            val oldValue = field
            field = newValue
            changeSupport.firePropertyChange("salary", oldValue, newValue)
        }
}

fun main(args: Array<String>) {
    val p = Person("Dmitry", 34, 2000)
    //新增監聽器
    p.addPropertyChangeListener(PropertyChangeListener { event ->
        println("Property ${event.propertyName} changed from ${event.oldValue} to ${event.newValue}")
    })
    p.age = 35
    p.salary = 2100
}

//輸出
Property age changed from 34 to 35
Property salary changed from 2000 to 2100
複製程式碼

setter中有很多重複的程式碼，我們來嘗試提取一個類，用來儲存這個屬性的值併發起通知。

class ObservableProperty(
        val propName: String, var propValue: Int, val changeSupport: PropertyChangeSupport
) {
    fun getValue(): Int = propValue
    fun setValue(newValue: Int) {
        val oldValue = propValue
        propValue = newValue
        changeSupport.firePropertyChange(propName, oldValue, newValue)
    }
}

class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
    val _age = ObservableProperty("age", age, changeSupport)

    var age: Int
        get() = _age.getValue()
        set(value) = _age.setValue(value)

    val _salary = ObservableProperty("salary", age, changeSupport)

    var salary: Int
        get() = _salary.getValue()
        set(value) = _salary.setValue(value)
}
複製程式碼

現在，你應該已經差不多理解了在Kotlin中，委託屬性是如何工作的。你建立了一個儲存屬性值的類，並在修改屬性時自動觸發更改通知。你刪除了重複的邏輯程式碼，但是需要相當多的樣板程式碼來為每個屬性建立ObservableProperty例項，並把getter和setter委託給它。Kotlin的委託屬性功能可以讓你擺脫這些樣板程式碼。但是在此之前，你需要更改ObservableProperty方法的簽名，來匹配Kotlin約定所需的方法。

class ObservableProperty(
        var propValue: Int, val changeSupport: PropertyChangeSupport
) {
    operator fun getValue(p: Person, prop: KProperty<*>): Int = propValue

    operator fun setValue(p: Person, prop: KProperty<*>, newValue: Int) {
        val oldValue = propValue
        propValue = newValue
        changeSupport.firePropertyChange(prop.name, oldValue, newValue)
    }
}
複製程式碼

與之前的版本相比，這次程式碼做了一些更改：

• 現在，按照也回到那個的需要，getValue和setValue函式被標記了operator
• 這些函式加了兩個引數：一個用於接收屬性的例項，用來設定或讀取屬性，另一個用於表示屬性本身。這個屬性型別為KProperty（之後章節會詳細介紹它），現在你只需要知道可以通過KProperty.name的方式來訪問該屬性的名稱。
• 把name屬性從主構造方法中刪除了，因為現在已經可以通過KProperty訪問屬性名稱。

終於，你可以見識Kotlin委託屬性的神奇了，來看看程式碼變短了多少？

class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
    var age: Int by ObservableProperty(age, changeSupport)
    var salary: Int by ObservableProperty(salary, changeSupport)
}
複製程式碼

通過關鍵字by，Kotlin編譯器會自動執行之前版本的程式碼中手動完成的操作。如果把這份程式碼與之前版本的Person類進行比較：使用委託屬性時生成的程式碼非常類似，右邊的物件被稱為委託。Kotlin會自動將委託儲存在隱藏的屬性中，並在訪問或修改屬性時呼叫委託的getValue和setValue。
你不用手動去實現可觀察的屬性邏輯，可以使用Kotlin標準庫，它已經包含了類似ObserverProperty的類。標準庫和這裡使用的PropertyChangeSupport類沒有耦合，因此，你需要傳遞一個lambda，來告訴它如何通知屬性值得更改，可以這樣做：

class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
    private val observer = {
        prop: KProperty<*>, oldValue: Int, newValue: Int ->
        changeSupport.firePropertyChange(prop.name, oldValue, newValue)
    }

    var age: Int by Delegates.observable(age, observer)
    var salary: Int by Delegates.observable(salary, observer)
}
複製程式碼

by右邊的表示式不一定是新建立的例項，也可以是函式呼叫，另一個屬性或任何其他表示式，只要這個表示式的值，是能夠被編譯器用正確的引數型別來呼叫getValue和setValue的物件。與其他約定一樣，getValue和setValue可以是物件自己生命的方法或擴充套件函式。
注意，為了讓示例保持簡單，我們只展示瞭如何使用型別為Int的委託屬性，委託屬性機制其實是通用的，適用於任何其他型別。

委託屬性的變換規則

讓我們來總結一下委託屬性是怎樣工作的，假設你已經有了一個具有委託屬性的類：

class C {
    var p: Type by MyDelegate()
}

val c = C()
複製程式碼

MyDelegate例項會儲存到一個隱藏的屬性中，它被稱為<delegate>。編譯器也將用一個KProperty型別的物件來代表這個屬性，它被稱為<property>。
編譯器生成的程式碼如下：

class C {
    private val <delegate> = MyDelegate()
    
    var prop: Type
        get() = <delegate>.getValue(this, <property>)
        set(value: Type) = <delegate>.setValue(this, <property>, value)
}
複製程式碼

因此，在每個屬性訪問器中，編譯器都會生成對應的getValue和setValue方法： val x = c.prop -> val x = <delegate>.getValue(c, <property>)
c,prop = x -> <delegate>.setValue(c, <property>, x)

這個機制非常簡單，但它可以實現許多有趣的場景。你可以自定義儲存該屬性值得位置（map、資料庫表或者使用者會話的Cookie中），以及在訪問該屬性時做點什麼（比如新增驗證、更改通知等）。

在map中儲存屬性值

委託屬性發揮作用的另一種常見用法，是用在有動態定義的屬性集的物件中。這樣的物件有時候被稱為自定（expando）物件。例如，考慮一個聯絡人管理系統，可以用來儲存有關聯絡人的任意資訊。系統中的每個人都有一些屬性需要特殊處理（例如名字），以及每個人特有的數量任意的額外屬性（例如，最小的孩子的生日）。 實現這種系統的一種方法是將人的所有屬性儲存在map中，不確定提供屬性，來訪問需要特殊處理的資訊。來看個例子：

class Person {
    private val _attributes = hashMapOf<String, String>()
    fun setAttribute(attrName: String, value: String) {
        _attributes[attrName] = value
    }
    
    val name: String
        get() = _attributes["name"]!!
}

fun main(args: Array<String>) {
    val p = Person()
    val data = mapOf("name" to "Dimtry", "company" to "JetBrans")
    for ((attrName, value) in data) {
        p.setAttribute(attrName, value)
    }
    println(p.name)
}

//輸出
Dimtry
複製程式碼

這裡使用了一個通用的API來吧資料載入到物件中（在實際專案中，可以是JSON反序列化或類似的方法），然後使用特定的API來訪問一個屬性的值。把它改為委託屬性非常簡單，可以直接將map放在by關鍵字後面。

class Person {
    private val _attributes = hashMapOf<String, String>()
    fun setAttribute(attrName: String, value: String) {
        _attributes[attrName] = value
    }

    val name: String by _attributes
}
複製程式碼

因為標準庫已經在標準Map和MutableMap介面上定義了getValue和setValue擴充套件函式，所以這裡可以直接這樣用。屬性的名稱將自動用作map中的鍵，屬性值作為map中的值。改動前p.name隱藏了_attributes.getValue(p, prop)的呼叫，改動後變為_attributes[prop.name]。