扩展概述
以 JDK 内置的集合 ArrayList 为例，如果我们想给其添加一个能力：交互两个元素 swap(index1, index2)。我们应该怎么做？常见的有如下方式：
- 工具类+静态方法，以 ArrayList 和要交换的两个 index 为入参，操作 ArrayList 交换元素；
- 继承 ArrayList 新写一个类，在类里面创建 swap() 方法，前提是基类是可以继承的，比如 java.lang.String 就不行；
- 使用组合的方式，写一个 ArrayListWrapper，内置一个 ArrayList，对外提供 swap() 方法
其实，这几种方式都存在劣势。不管是工具类还是继承的方式还是装饰者模式的组合类，都是新建了一个类，很可能有同事以前已经创建了这个类了。但是如果你不知道新类的名字是啥，就很尴尬了。或者懒得问干脆自己新建一个，一个新的“轮子”诞生了。
如果我们在 AndroidStudio 里面输入 ArrayList 就能自动提示 swap 这个函数就好了，就跟原本就有这个方法一样。唉~~Kotlin 就提供了这种能力，这就是扩展。
扩展函数
继续以 swap() 方法为例。我们在 Kotlin 中使用如下格式完成，先定义 swap() 方法：
fun <T> MutableList<T>?.swap(i1: Int, i2: Int) {
if (this == null) {
return
}
val tmp = this[i1]
this[i1] = this[i2]
this[i2] = tmp
}
不失一般性的，如果我们想向某个已经存在的类 ReceiverClassType 中“添加”一个函数 func，那么我们可以写成：
ReceiverClassType.func()
如果允许接收空值，则可以写成：
ReceiverClassType?.func()
知道了定义格式，如何使用扩展函数呢？这样：
val list = mutableListOf(1, 2, 3)
list.swap(0, 2)
扩展函数在安卓开发中也有用武之地，比如我们要给原生控件 ImageView 扩展支持加载网络图片的功能，有了扩展之后我们可以这么做：
import android.widget.ImageView
import com.bumptech.glide.Glide
fun ImageView.loadImage(url: String) {
Glide.with(this).load(url).into(this)
}
再比如，我们要给原生控件 TextView 添加富文本的能力，后端网络接口返回给前端一个 JSON 数组，数组里面的每个元素代表文本中的一段子串的样式：
fun TextView.setRichText(jsonArray: String) {
val builder: SpannableStringBuilder = parse(jsonArray)
setText(builder)
}
简单了解用法之后，一大串问题就来了：
- 扩展函数的实现原理是什么？
- 扩展函数放在什么位置呢？
- 可以有可见性修饰符吗？
- 可以作为类的成员方法吗？如果可以，支持重载、重写、多态吗？
- 如果扩展函数与成员函数冲突了，谁的优先级更高呢？
- 如何从 Java 代码里面调用扩展函数呢？
实现原理
继续以上面的 swap() 方法为例，我们看下其反编译出来的 Java 代码：
public final class SwapKt {
public static final void swap(@Nullable List $this$swap, int index1, int index2) {
if ($this$swap != null) {
Object tmp = $this$swap.get(index1);
$this$swap.set(index1, $this$swap.get(index2));
$this$swap.set(index2, tmp);
}
}
}
其实就是一个工具类+static方法，并没有真的向目标类添加新的方法。
如果我们想在 Java 代码中引用扩展函数，我们需要使用 SwapKt.swap() 的形式：
import example.kotlin.pkg.SwapKt;
import java.util.ArrayList;
ArrayList<Integer> list = new ArrayList<>();
list.add(0);
list.add(1);
SwapKt.swap(list, 0 ,1);
放置位置
我们知道，kotlin 的普通函数是可以放置在单个文件里面（也就是 top-level），也可以作为成员函数放置在类体内，扩展函数也不例外。
我们能以 top-level 的形式放在单个文件 Swap.kt 中：
package example.kotlin.pkg
fun <T> MutableList<T>?.swap(index1: Int, index2: Int) {
// ...
}
扩展函数也可以作为成员函数，即将类 A 的扩展函数在类 B 中定义，我们称 A 为接收类型（Receiver Type），称 B 为分发类型（Dispatch Type）。比如下面示例代码中的 Host 就是接收类型，而 Connection 是分发类型：
class Host(val hostname: String) {
fun printHost() {
print(hostname)
}
}
class Connection(val host: Host, val port: Int) {
fun printPort() {
print(port)
}
fun Host.printConnectionString() {
host.printHost()
print(":")
printPort()
}
fun connect() {
host.printConnectionString()
}
}
fun main() {
Connection(Host("kotl.in"), 443).connect()
//Host("kotl.in").printConnectionString() // error, the extension function is unavailable outside Connection
}
既然在分发类型中定义接收类型的扩展方法，那在扩展方法中引用 this 究竟是谁呢？接收类型还是分发类型的？实际是接收类型的，如果想引用分发类型的 this，需要使用 this@DispatchType：
class Connection {
fun Host.getConnectionString() {
toString() // calls Host.toString()
this@Connection.toString() // calls Connection.toString()
}
}
既然扩展函数可以以成员函数的形式出现，那么就有成员函数的相应“待遇”：重写、重载、多态等，但这些“待遇”都是分发类型才有的，而接收类型是没有的，接收类型的函数都是静态引用，只跟接收类型有关，先来看个例子：
open class Shape
class Rectangle: Shape()
fun Shape.getName() = "Shape"
fun Rectangle.getName() = "Rectangle"
fun printClassName(s: Shape) { // 只由 Shape 决定，而非其子类
println(s.getName())
}
// 输出 Shape
printClassName(Rectangle())
// 输出 Shape
val shape: Shape = Rectangle()
printClassName(shape)
// 输出 Shape
val rect: Rectangle = Rectangle()
printClassName(rect as Shape)
在来看个更复杂的：
open class Shape
class Rectangle: Shape()
open class ShapeCaller {
open fun Shape.getName() = "Shape in ShapeCaller"
open fun Rectangle.getName() = "Rectangle in ShapeCaller"
fun call(s: Shape) {
println(s.getName())
}
}
class RectangleCaller: ShapeCaller() {
override fun Shape.getName() = "Shape in RectangleCaller"
override fun Rectangle.getName() = "Rectangle in RectangleCaller"
}
fun main() {
ShapeCaller().call(Shape()) // 输出 Shape in ShapeCaller
ShapeCaller().call(Rectangle()) // 输出 Shape in ShapeCaller
RectangleCaller().call(Shape()) // 输出 Shape in RectangleCaller
RectangleCaller().call(Rectangle()) // 输出 Shape in RectangleCaller
}
由于 call(s: Shape) 里面的接收类型是 Shape，所有不能是 ShapeCaller 还是 RectangleCaller 都只会调用 Shape.getName()，但是调用父类还是子类里面的 Shape.getName() 却是符合多态的，具体决定于分发类型是 ShapeCaller 还是 RectangleCaller。
如果扩展函数和成员函数签名完全一致，那么成员函数优先级更高。
扩展属性
与扩展函数类似，Kotlin 还支持扩展属性。使用方法也类似，比如我们要给 MutableList 扩展一个本不存在的属性 lastIndex：
val <T> MutableList<T>?.lastIndex: Int
get() {
if (this == null) {
return -1
}
return size - 1
}
注意，因为扩展属性是本不存在的，因此其没有 Backing Field，我们也无法直接对其赋值，因此扩展属性只能是 val 类型的，否则会报错：
fun play() {
val list = mutableListOf<String>()
print(list.lastIndex)
list.lastIndex = 1 // 报错
// 结合扩展函数 swap() 实现交换首位元素
list.swap(0, list.lastIndex)
}
最佳实践
在实际开发中，优先使用成员函数还是扩展函数呢？答案是优先使用成员函数，只有在无法使用成员函数，比如无法修改既有类或者虽然可以修改但是想控制使用权限的时候，再使用扩展函数。
同时，结合 infix 关键字我们可以实现很酷的功能，比如：
val ago = "ago"
infix fun Int.days(tense: String) = when (tense) {
ago -> "2021-10-04 11:39:27"
else -> "?"
}
fun main() {
// val _2daysAgo = 2.days(ago)
val _2daysAgo = 2 days ago
println(_2daysAgo)
}
谁能想到 2 days ago 就是一行代码呢？而且是可以直接正常运行的代码，简直不要太酷！
更多常用扩展属性和方法见我的 Gist：Frequently used Kotlin extensions for Android。
参考资料
