Kotlin 擴展
Kotlin 可以對一個類的屬性和方法進行擴展，且不需要繼承或使用 Decorator 模式。
擴展是一種靜態行為，對被擴展的類代碼本身不會造成任何影響。
擴展函數
擴展函數可以在已有類中添加新的方法，不會對原類做修改，擴展函數定義形式：
fun receiverType.functionName(params){
body
}
- receiverType：表示函數的接收者，也就是函數擴展的對象
- functionName：擴展函數的名稱
- params：擴展函數的參數，可以為NULL
以下實例擴展 User 類 ：
class User(var name:String)
/**擴展函數**/
fun User.Print(){
print("用戶名 $name")
}
fun main(arg:Array<String>){
var user = User("Runoob")
user.Print()
}
實例執行輸出結果為：
用戶名 Runoob
下面代碼為 MutableList
// 擴展函數 swap,調換不同位置的值
fun MutableList<Int>.swap(index1: Int, index2: Int) {
val tmp = this[index1] // this 對應該列表
this[index1] = this[index2]
this[index2] = tmp
}
fun main(args: Array<String>) {
val l = mutableListOf(1, 2, 3)
// 位置 0 和 2 的值做了互換
l.swap(0, 2) // 'swap()' 函數內的 'this' 將指向 'l' 的值
println(l.toString())
}
實例執行輸出結果為：
[3, 2, 1]
this關鍵字指代接收者對象(receiver object)(也就是調用擴展函數時, 在點號之前指定的對象實例)。
擴展函數是靜態解析的
擴展函數是靜態解析的，併不是接收者類型的虛擬成員，在調用擴展函數時，具體被調用的的是哪一個函數，由調用函數的的對象表達式來決定的，而不是動態的類型決定的:
open class C
class D: C()
fun C.foo() = "c" // 擴展函數 foo
fun D.foo() = "d" // 擴展函數 foo
fun printFoo(c: C) {
println(c.foo()) // 類型是 C 類
}
fun main(arg:Array<String>){
printFoo(D())
}
實例執行輸出結果為：
c
若擴展函數和成員函數一致，則使用該函數時，會優先使用成員函數。
class C {
fun foo() { println("成員函數") }
}
fun C.foo() { println("擴展函數") }
fun main(arg:Array<String>){
var c = C()
c.foo()
}
實例執行輸出結果為：
成員函數
擴展一個空對象
在擴展函數內， 可以通過 this 來判斷接收者是否為 NULL,這樣，即使接收者為 NULL,也可以調用擴展函數。例如:
fun Any?.toString(): String {
if (this == null) return "null"
// 空檢測之後，“this”會自動轉換為非空類型，所以下面的 toString()
// 解析為 Any 類的成員函數
return toString()
}
fun main(arg:Array<String>){
var t = null
println(t.toString())
}
實例執行輸出結果為：
null
>擴展屬性
除了函數，Kotlin 也支持屬性對屬性進行擴展:
val <T> List<T>.lastIndex: Int
get() = size - 1
擴展屬性允許定義在類或者kotlin文件中，不允許定義在函數中。初始化屬性因為屬性沒有後端字段（backing field），所以不允許被初始化，只能由顯式提供的 getter/setter 定義。
val Foo.bar = 1 // 錯誤：擴展屬性不能有初始化器
擴展屬性只能被聲明為 val。
伴生對象的擴展
如果一個類定義有一個伴生對象 ，你也可以為伴生對象定義擴展函數和屬性。
伴生對象通過"類名."形式調用伴生對象，伴生對象聲明的擴展函數，通過用類名限定符來調用：
class MyClass {
companion object { } // 將被稱為 "Companion"
}
fun MyClass.Companion.foo() {
println("伴隨對象的擴展函數")
}
val MyClass.Companion.no: Int
get() = 10
fun main(args: Array<String>) {
println("no:${MyClass.no}")
MyClass.foo()
}
實例執行輸出結果為：
no:10 伴隨對象的擴展函數
擴展的作用域
通常擴展函數或屬性定義在頂級包下:
package foo.bar
fun Baz.goo() { …… }
要使用所定義包之外的一個擴展, 通過import導入擴展的函數名進行使用:
package com.example.usage
import foo.bar.goo // 導入所有名為 goo 的擴展
// 或者
import foo.bar.* // 從 foo.bar 導入一切
fun usage(baz: Baz) {
baz.goo()
}
擴展聲明為成員
在一個類內部你可以為另一個類聲明擴展。
在這個擴展中，有個多個隱含的接受者，其中擴展方法定義所在類的實例稱為分發接受者，而擴展方法的目標類型的實例稱為擴展接受者。
class D {
fun bar() { println("D bar") }
}
class C {
fun baz() { println("C baz") }
fun D.foo() {
bar() // 調用 D.bar
baz() // 調用 C.baz
}
fun caller(d: D) {
d.foo() // 調用擴展函數
}
}
fun main(args: Array<String>) {
val c: C = C()
val d: D = D()
c.caller(d)
}
實例執行輸出結果為：
D bar C baz
在 C 類內，創建了 D 類的擴展。此時，C 被成為分發接受者，而 D 為擴展接受者。從上例中，可以清楚的看到，在擴展函數中，可以調用派發接收者的成員函數。
假如在調用某一個函數，而該函數在分發接受者和擴展接受者均存在，則以擴展接收者優先，要引用分發接收者的成員你可以使用限定的 this 語法。
class D {
fun bar() { println("D bar") }
}
class C {
fun bar() { println("C bar") } // 與 D 類 的 bar 同名
fun D.foo() {
bar() // 調用 D.bar()，擴展接收者優先
this@C.bar() // 調用 C.bar()
}
fun caller(d: D) {
d.foo() // 調用擴展函數
}
}
fun main(args: Array<String>) {
val c: C = C()
val d: D = D()
c.caller(d)
}
實例執行輸出結果為：
D bar C bar
以成員的形式定義的擴展函數, 可以聲明為 open , 而且可以在子類中覆蓋. 也就是說, 在這類擴展函數的派 發過程中, 針對分發接受者是虛擬的(virtual), 但針對擴展接受者仍然是靜態的。
open class D {
}
class D1 : D() {
}
open class C {
open fun D.foo() {
println("D.foo in C")
}
open fun D1.foo() {
println("D1.foo in C")
}
fun caller(d: D) {
d.foo() // 調用擴展函數
}
}
class C1 : C() {
override fun D.foo() {
println("D.foo in C1")
}
override fun D1.foo() {
println("D1.foo in C1")
}
}
fun main(args: Array<String>) {
C().caller(D()) // 輸出 "D.foo in C"
C1().caller(D()) // 輸出 "D.foo in C1" —— 分發接收者虛擬解析
C().caller(D1()) // 輸出 "D.foo in C" —— 擴展接收者靜態解析
}
實例執行輸出結果為：
D.foo in C D.foo in C1 D.foo in C