扩展函数是静态解析的，并不是接收者类型的虚拟成员
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<String>){
printFoo(D())
}
输出 ： c
2，若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。
class C {
fun foo() { println("成员函数") }
}
fun C.foo() { println("扩展函数") }
fun main(arg:Array<String>){
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<String>){
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()
this@C.toString() // 调用 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 成员函数，输出都不会变
