Kotlin 扩展

扩展函数是静态解析的，并不是接收者类型的虚拟成员
1，调用的函数与定义的类有关，与具体类无关
在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的

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){
    printFoo(D())
}

输出 ： c

2，若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

 class C {
    fun foo() { println("成员函数") }
}

fun C.foo() { println("扩展函数") }

fun main(arg:Array){
    var c = C()
    c.foo()
}

输出：成员函数

3，可以对NULL添加扩展函数， 通过 this 来判断接收者是否为 NULL,即使接收者为 NULL,也可以调用扩展函数。

fun Any?.toString(): String {
    if (this == null) return "null"
    // 空检测之后，“this”会自动转换为非空类型，所以下面的 toString()
    // 解析为 Any 类的成员函数
    return toString()
}
fun main(arg:Array){
    var t = null
    println(t.toString())
}

4，在另一个类的内部扩展，既可以直接访问本类函数，也可以访问声明类里的函数
在一个类内部可以为另一个类声明扩展。扩展声明所在的类的实例称为 分发接收者，扩展方法调用所在的接收者类型的实例称为 扩展接收者 。对于分发接收者与扩展接收者的成员名字冲突的情况，扩展接收者优先。

class D { //扩展接收者
    fun bar() { …… }
}

class C { // 分发接收者
    fun baz() { …… }

    fun D.foo() {
        bar()   // 调用 D.bar
        baz()   // 调用 C.baz
    }

    fun caller(d: D) {
        d.foo()   // 调用扩展函数
    }
// 情况二
    fun D.foo() {
        toString()         // 调用 D.toString()
        [email protected]()  // 调用 C.toString()
    }
}

所以函数名相同的情况下，优先级是 成员函数 > 扩展函数 > 分发者函数
5，声明为成员的扩展可以声明为 open 并在子类中覆盖。这意味着这些函数的分发对于分发接收者类型是虚拟的，但对于扩展接收者类型是静态的。
从子到父，就近使用扩展函数

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() {
    C().caller(D())   // 输出 "D.foo in C"
    C1().caller(D())  // 输出 "D.foo in C1" —— 分发接收者虚拟解析
    C().caller(D1())  // 输出 "D.foo in C" —— 扩展接收者静态解析
}

// 当添加函数
fun caller(d: D1) {
      d.foo()   // 调用扩展函数
}
fun main() {
    C().caller(D())   // 输出 "D.foo in C"
    C1().caller(D())  // 输出 "D.foo in C1" —— 分发接收者虚拟解析
    C().caller(D1())  // 输出 "D1.foo in C" 
}

// 如果定义了 foo 成员函数，输出都不会变