系列文章全部为本人的学习笔记，若有任何不妥之处，随时欢迎拍砖指正。如果你觉得我的文章对你有用，欢迎关注我，我们一起学习进步！
Kotlin学习笔记（1）- 环境配置
Kotlin学习笔记（2）- 空安全
Kotlin学习笔记（3）- 语法
Kotlin学习笔记（4）- 流程控制
Kotlin学习笔记（5）- 类
Kotlin学习笔记（6）- 属性
Kotlin学习笔记（7）- 接口
Kotlin学习笔记（8）- 扩展
Kotlin学习笔记（8）- 扩展（续）
Kotlin学习笔记（9）- 数据类
Kotlin学习笔记（10）- 泛型
Kotlin学习笔记（11）- 内部类和嵌套类
Kotlin学习笔记（12）- 委托
Kotlin学习笔记（13）- 函数式编程
Kotlin学习笔记（14）- lambda

昨天学习了kotlin的扩展，在体会到扩展的强大的同时，也产生了一些疑惑，具体请移步《Kotlin学习笔记（8）- 扩展》，当然如果你对扩展的了解不多，也可以看一下。昨天又查了一些资料，对问题也有了一些了解，这里写出来算是对自己一个交代。同时看到一些大神提到的一些关于扩展的点，确实是昨天没有想到的，今天也补充上。那么也就沿用昨天的标题了

五、可见范围

扩展通常写在包名下，与包名同级，这样写的好处是全部可见，通过导入包名+扩展名的方式，就可以进行引用。

package com.study.jcking.weatherkotlin.exec     // 包名
import...
fun Any?.string() : String = if(this == null) "null obj" else toString()  // 扩展方法

import com.study.jcking.weatherkotlin.exec.string   // 在其他类中这么导入，即可直接使用

除此之外，也可在类中进行其他类的扩展，但是这种扩展只在类自身及子类中可见，也就是说，在类中对其他类进行扩展，可以看成是类的成员。扩展不能定义在类的方法中。

class Target {
    fun m1(){
        Log.d("test", "Target.m1")
    }
}

// Shoot中对Target扩展了m2方法，m2方法仅在Shoot中可见
class Shoot {
    fun Target.m2() {
        Log.d("test", "Target.m2 in Shoot")
    }
    
    fun shoot(){
        Target().m2()
    }
}
// m2方法在其他类中不可见
class Work {
    fun work(){
        Shoot().shoot()
        Target().m1()
    }
}

六、扩展成员调用冲突

解释一下标题，就是说如果扩展的方法和已有的方法冲突，那此时的调用原则是什么呢？这里沿用一个大神的定义：

如果一个类A的内部为另一个类B定义了扩展，那么类A被称为派发接受者，类B被称为扩展接受者

1. 既然扩展方法在派发接受者中定义扩展，那么它能不能调用派发接受者的方法？答案是可以的

   class Target {
       fun m1(){
           Log.d(TAG, "Target.m1")
       }
   }
   
   class Shoot {
       fun m(){
           Log.d(TAG, "Shoot.m in Shoot")
       }
   
       fun Target.m2() {
           m()
           m1()
       }
   
       fun shoot(){
           Target().m2()
       }
   }
   
   fun work(){
       Shoot().shoot()
   }
   
   // 输出
   Shoot.m in Shoot
   Target.m1
   

2. 既然扩展方法可以调用派发接受者中的方法，那如果派发接受者和扩展接受者中相同的方法，那会怎么处理呢？我们将Shoot类的m方法重命名为m1，再来看一下

   class Shoot {
       fun m1(){
           Log.d(TAG, "Shoot.m in Shoot")
       }
   
       fun Target.m2() {
           m1()
       }
   
       fun shoot(){
           Target().m2()
       }
   }
   
   // 输出
   Target.m1
   

   可以看到，输出为扩展接受者中的结果，也就是说：当派发接受者与扩展接受者的成员名称发生冲突时, 扩展接受者的成员将会被优先使用。那如果我们就是想让扩展方法调用派发接受者的方法呢？这时就要用到this@label用法了，这种用法的label表示指定范围，比如我们想要使用Shoot中的方法，那么就是this@Shoot，我们再来看一下

   class Shoot {
       fun m1(){
           Log.d(TAG, "Shoot.m in Shoot")
       }
   
       fun Target.m2() {
           m1()
           this@Shoot.m1()
       }
   
       fun shoot(){
           Target().m2()
       }
   }
   
   // 输出
   Target.m1
   Shoot.m1 in Shoot
   

3. 我们再来考虑下一个冲突，就是扩展的方法如果和扩展接受者中的已有方法冲突，又会如何呢？

   class Target {
       fun m1(){
           Log.d(TAG, "Target.m1 in self")
       }
   }
   
   class Shoot {
       fun m1(){
           Log.d(TAG, "Shoot.m1 in Shoot")
       }
   
       fun Target.m1() {
           Log.d(TAG, "Target.m1 in Shoot")
       }
   
       fun shoot(){
           Target().m1()
       }
   }
   
   fun work(){
       Shoot().shoot()
   }
   
   // 输出
   Target.m1 in self
   

   可以看到，我们定义了Target的m1方法，又在Shoot扩展了同名方法，在log中可以看到，首先被调用的是Target中自身的方法。也就是说：如果扩展的方法与类中原生的方法相同，则会优先使用原生方法。

4. 扩展函数是静态解析的，也就是，它并不是接收者类型的虚拟成员，意味着调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的。

   open class Target
   
   class Target2 : Target()
   
   class Shoot {
       fun Target.m1() {
           Log.d(TAG, "Target.m1 in Shoot")
       }
   
       fun Target2.m1() {
           Log.d(TAG, "Target2.m1 in Shoot")
       }
   
       fun shoot(){
           var t1 : Target = Target()
           var t2 : Target = Target2()
           var t3 : Target2 = Target2()
           var t4 = Target2()
           t1.m1()         // Target.m1 in Shoot
           t2.m1()         // Target.m1 in Shoot
           t3.m1()         // Target2.m1 in Shoot
           t4.m1()         // Target2.m1 in Shoot
       }
   }
   
   fun work(){
       Shoot().shoot()
   }
   

   根据输出我们可以看到，扩展方法的调用，是由调用函数的的声明对象类型来决定的，而不是动态的类型决定的。当没有直接指定调用对象时（例如t4），编辑器会自动匹配最符合表达式的值的类型。

参考

行云间的博客：Kotlin-扩展