7 扩展：你的能力边界到底在哪里？

Kotlin的扩展（Extension），主要分为两种语法：第一个是扩展函数，第二个是扩展属性。从语法上看，扩展看起来就像是我们从类的外部为它扩展了新的成员。

这在实际编程当中是非常有用的功能。我们可以来想象一个场景：我们想修改JDK当中的String，想在它的基础上增加一个方法“lastElement()”来获取末尾元素，如果使用Java，我们是无法通过常规手段实现的，因为我们没办法修改JDK的源代码。任何第三方提供的SDK，我们都无权修改。

不过，借助Kotlin的扩展函数，我们就完全可以在语义层面，来为第三方SDK的类扩展新的成员方法和成员属性。不管是为JDK的String增加新的成员方法，还是为Android SDK的View增加新成员属性，我们都可以实现。

Kotlin的这个“扩展”功能看起来很神奇，它会不会很难学？其实不然，它的语法非常简洁。今天这节课，我们就一起来学习下Kotlin当中的扩展。通过研究它的原理，来探索它的能力边界，并在理解和掌握核心知识点之后，去思考它的实战应用场景。

### 什么是扩展函数和扩展属性？
扩展函数，就是从类的外部扩展出来的一个函数，这个函数看起来就像是类的成员函数一样。这里，我们就以JDK当中的String为例，来看看如何通过Kotlin的扩展特性，为它新增一个`lastElement()`方法。
```kotlin
// Ext.kt
package com.boycoder.chapter06

/*
 ①    ②      ③            ④
 ↓     ↓       ↓            ↓      */
fun String.lastElement(): Char? {
    //    ⑤
    //    ↓
    if (this.isEmpty()) {
        return null
    }

return this[length - 1]
}

// 使用扩展函数
fun main() {
    val msg = "Hello Wolrd"
    // lastElement就像String的成员方法一样可以直接调用
    val last = msg.lastElement() // last = d
}
```
我们先是定义了一个String的扩展函数“lastElement()”，然后在main函数当中调用了这个函数。并且，这个扩展函数是直接定义在Kotlin文件里的，而不是定义在某个类当中的。这种扩展函数，我们称之为“顶层扩展”，这么叫它是因为它并没有嵌套在任何的类当中，它自身就在最外层。

现在，我们依次来看看上面的五处注释。
- 注释①，fun关键字，代表我们要定义一个函数。也就是说，不管是定义普通Kotlin函数，还是定义扩展函数，我们都需要fun关键字。
- 注释②，“String.”，代表我们的扩展函数是为String这个类定义的。在Kotlin当中，它有一个名字，叫做接收者（Receiver），也就是扩展函数的接收方。
- 注释③，lastElement()，是我们定义的扩展函数的名称。
- 注释④，“Char?”，代表扩展函数的返回值是可能为空的Char类型。
- 注释⑤，“this.”，代表“具体的String对象”，当我们调用 msg.lastElement() 的时候，this就代表了msg。

需要注意的是，在整个扩展函数的方法体当中，this都是可以省略的。这一点，Kotlin和Java是一样的，this代表当前作用域，它可写可不写。

另外，如果你足够细心的话，你会发现如果去掉注释②处的“String.”，这段代码就会变成一个普通的函数定义：
```kotlin
fun lastElement(): Char? {}

fun String.lastElement(): Char? {}
// 普通函数与扩展函数之间的差别
```
换句话说，就是如果我们在普通函数的名称前面加上一个“接收者类型”，比如“String.”，Kotlin的“普通函数”就变成了“扩展函数”。

可见，Kotlin扩展语法设计得非常巧妙，只要你记住了普通函数的语法，那么，只需要再记住一点点细微的区别，你就能记住扩展函数的语法。而通过这个细微的语法差异，你也可以体会到，所谓的扩展函数，就是多了个“扩展接收者”的函数。

### 扩展函数的实现原理
在第3讲中，我们学习了如何研究Kotlin的原理，也就是通过Java字节码来做反编译。那么在这里，我们就以刚才写的lastElement()为例，一起来看看它反编译后的Java代码是什么样的。
```kotlin
public final class ExtKt {
   // ①
   public static final Character lastElement(String $this) {
      CharSequence var1 = (CharSequence)$this;
      if (var1.length() == 0) {
        return null
      }

return  var1.charAt(var1.length() - 1);
   }
}

public static final void main() {
  String msg = "Hello Wolrd";
  //                        ②
  //                        ↓
  Character last = ExtKt.lastElement(msg);
}
```
以上代码有两个地方需要注意，我分别用两个注释标记出来了。
- 通过第一个注释，我们可以看到，原本定义在String类型上面的扩展函数`lastElement()`，变成了一个普通的静态方法。另外，之前定义的扩展函数`lastElement()`是没有参数的，但反编译后的Java代码中，``lastElement(String $this) `多了一个String类型的参数。
- 还有第二个注释，这是扩展函数的调用处，原本msg.lastElement()的地方，变成了`ExtKt.lastElement(msg)`。这说明，Kotlin编写的扩展函数调用代码，最终会变成静态方法的调用。

看到这里，也许你一下就能反应过来：Kotlin的扩展函数只是从表面上将`lastElement()`变成String的成员，但它实际上并没有修改String这个类的源代码，`lastElement()`也并没有真正变成String的成员方法。

也就是说，由于JVM不理解Kotlin的扩展语法，所以Kotlin编译器会将扩展函数转换成对应的静态方法，而扩展函数调用处的代码也会被转换成静态方法的调用。

而如果我们将上面的ExtKt修改成StringUtils，它就变成了典型的Java工具类。
```kotlin
public final class StringUtils {
   public static final Character lastElement(String $this) {
     // 省略
   }
}

public static final void main() {
  Character last = StringUtils.lastElement(msg);
}
```
### 如何理解扩展属性？
在学习了Kotlin的扩展函数以后，扩展属性就很好理解了。扩展函数，是在类的外部为它定义一个新的成员方法；而扩展属性，则是在类的外部为它定义一个新的成员属性。

那么，在研究了扩展的实现原理后，我们知道，我们从外部定义的成员方法和属性，都只是语法层面的，并没有实际修改那个类的源代码。

还是以lastElement为例，在之前的案例当中，我们是通过扩展函数来实现的，这次我们以扩展属性的方式来实现。扩展函数的定义对比普通函数，其实就只是多了一个“接收者类型”。类似的，扩展属性，也就是在普通属性定义的时候多加一个“接收者类型”即可。
```kotlin
// 接收者类型
//     ↓
val String.lastElement: Char?
    get() = if (isEmpty()) {
            null
        } else {
            get(length - 1)
        }

fun main() {
    val msg = "Hello Wolrd"
    // lastElement就像String的成员属性一样可以直接调用
    val last = msg.lastElement // last = d
}
```
在这段的代码中，我们为String类型扩展了一个新的成员属性`lastElement`。然后在main函数当中，我们直接通过`msg.lastElement`方式使用了这个扩展属性，就好像它是一个成员一样。而如果你将以上的代码进行反编译，你会发现它反编译后的Java代码几乎和我们前面扩展函数的一模一样。

为了让你看得更加清晰，我们用一张图来描述它们之间的关系。
![](/media/202410/2024-10-28_111438_1967360.44345796608558496.png)
上面的两个箭头，说明了扩展函数与扩展属性，它们最终会被Kotlin编译器转换成静态方法；下面两个箭头，说明了扩展函数和扩展属性的调用代码，最终会被Kotlin编译器转换成静态方法的调用。

所以也就是说，Kotlin的扩展表面上看起来是为一个类扩展了新的成员，但是本质上，它还是静态方法。而且，不管是扩展函数还是扩展属性，它本质上都会变成一个静态的方法。那么，到底什么时候该用扩展函数，什么时候该用扩展属性呢？

其实，我们只需要看扩展在语义上更适合作为函数还是属性就够了。比如这里的lastElement，它更适合作为一个扩展属性。这样设计的话，在语义上，lastElement就像是String类当中的属性一样，它代表了字符串里的最后一个字符。

### 扩展的能力边界
在理解了扩展的使用与原理后，我们再来探讨一下扩展的能力边界：扩展能做什么，不能做什么。Kotlin的扩展看起来很神奇，但它并不是无所不能的，通过探索它的能力边界，我们就能对它有一个更加深入的认识。

#### 扩展能做什么？
我们先从“扩展能做什么”说起。

当我们想要从外部为一个类扩展一些方法和属性的时候，我们就可以通过扩展来实现了。在Kotlin当中，几乎所有的类都可以被扩展，包括普通类、单例类、密封类、枚举类、伴生对象，甚至还包括第三方提供的Java类。唯有匿名内部类，由于它本身不存在名称，我们无法指定“接收者类型”，所以不能被扩展，当然了，它也没必要被扩展。

可以说，Kotlin扩展的应用范围还是非常广的。它最主要的用途，就是用来取代Java当中的各种工具类，比如StringUtils、DateUtils等等。

所有Java工具类能做的事情，Kotlin扩展函数都可以做，并且可以做得更好。扩展函数的优势在于，开发工具可以在编写代码的时候智能提示。
![](/media/202410/239e540b768560c6cd119b1bb9e1eb9c_1730085321.gif)

#### 扩展不能做什么？
我们再聊聊扩展不能做什么。

Kotlin的扩展，由于它本质上并没有修改接收类型的源代码，所以它的行为是无法与“类成员”完全一致的。那么它对比普通的类成员，就会有以下几个限制。
- 第一个限制，Kotlin扩展不是真正的类成员，因此它无法被它的子类重写。举个例子，我们定义一个这样的Person类，并且分别为它扩展了一个isAdult属性和 `walk()`方法：
```kotlin
	open class Person {
    	var name: String = ""
    	var age: Int = 0
	}

val Person.isAdult: Boolean
    	get() = age >= 18

fun Person.walk() {
    	println("walk")
	}
```
由于Person类有open关键字修饰，所以我们可以继承这个Person类。不过，当我们尝试去重写它的成员时，会发现`isAdult`和`walk()`是无法被重写的，因为它们压根就不属于Person这个类。这个很好理解，让我们看下一个。

- 第二个限制，扩展属性无法存储状态。就如前面代码当中的isAdult属性一般，它的值是由age这个成员属性决定的，它本身没有状态，也无法存储状态。这一点，和我们在第2讲学习的“接口成员属性”一样，背后的根本原因，还是因为它们都是静态方法。

- 第三个限制，扩展的访问作用域仅限于两个地方。第一，定义处的成员；第二，接收者类型的公开成员。我们以前面的代码为例：
```kotlin
	// Ext.kt
	package com.boycoder.chapter06

// ①
	private val msg: String = ""

fun String.lastElement(): Char? {
    	if (this.isEmpty()) {
			//       ②
        	//       ↓
        	println(msg)
        	return null
    	}

//            ③
    	//            ↓
    	return this[length - 1]
	}
```
这段代码一共有三处注释，我们一个个看：
	- 在注释①的地方，我们在Ext这个Kotlin文件里定义了一个私有的变量msg。
	- 由于lastElement()与msg是定义在同一个文件当中的，因此，在注释②处我们可以直接访问msg，即使它是私有的。
	- 最后，是注释③，由于length是String类的公开属性，因此我们可以在扩展函数当中直接访问它。对应的，如果length是String的private、protected成员，那我们将无法在扩展函数当中访问它。归根结底，还是因为扩展函数并非真正的类成员。

看到这里，也许你会冒出一个有趣的想法：如果将扩展定义在某个类的内部，它能够访问这个类的私有属性吗？

让我们来试试看：
```kotlin
	open class Person {
    	var name: String = ""
    	var age: Int = 0
	}

class Helper {
    	private fun walkOnFoot() {
        	println("用脚走路")
    	}
    	val Person.isAdult: Boolean
        	get() = age >= 18

fun Person.walk() {
        	// 调用了Helper的私有方法
        	walkOnFoot()
    	}

fun test() {
        	val person = Person()
        	// 仅可以在Helper类当中使用此扩展
        	person.walk()
    	}
	}
```
我们创建了一个Helper类，它内部有一个私有的成员方法，同时，我们在这个类的内部定义了一个扩展属性和一个扩展函数。可以看到，我们在扩展函数`walk()`方法当中，能直接调用Helper类的私有成员方法`walkOnFoot()`，这体现了类的内部定义扩展的优势。

但是与此同时，这种方式定义的扩展也存在一个劣势，那就是无法在Helper类的外部作为扩展被调用。如果你将上面的代码反编译成Java，你会发现，我们定义的内部扩展，最终都变成了Helper类的普通成员函数和成员属性。

所以，针对扩展的第三个限制来说：
	- 如果扩展是顶层的扩展，那么扩展的访问域仅限于该Kotlin文件当中的所有成员，以及被扩展类型的公开成员，这种方式定义的扩展是可以被全局使用的。
	- 如果扩展是被定义在某个类当中的，那么该扩展的访问域仅限于该类当中的所有成员，以及被扩展类型的公开成员，这种方式定义的扩展仅能在该类当中使用。

### 实战与思考
到这里，我们就了解了Kotlin的扩展，包括扩展函数、扩展属性以及扩展的实现原理，同时我们也在了解它原理的基础上分析了它的能力边界。

不过，即使在学习完上面所有的知识点后，你也许还是不太清楚Kotlin扩展的实际使用场景。所以下面，我再带你来看两个案例，这两个工业界的实际案例，可以完美地向你展示Kotlin扩展的两个核心使用场景。你可以通过学习这两种思路，将其运用在实际的工作当中。

第一个案例，是来自Kotlin标准库当中的源代码。我们先看看在Kotlin当中，String.kt的源代码是什么样的：
```kotlin
// String.kt
public class String : Comparable, CharSequence {
    companion object {}

public operator fun plus(other: Any?): String

public override val length: Int

public override fun get(index: Int): Char

public override fun subSequence(startIndex: Int, endIndex: Int): CharSequence

public override fun compareTo(other: String): Int
}
```
你一定会很惊讶，Kotlin里面的String类竟然只有不到十行代码。那么，String类的那些字符操作的方法到哪里去了？比如，`String.trim()`、`String.lowercase()`它们定义在什么地方？

实际上，String相关的操作方法全都放到了Strings.kt当中去了。而这些字符操作方法全部都是以扩展函数的方式定义的：
```kotlin
// Strings.kt 部分代码

public fun CharSequence.trim(): CharSequence = trim(Char::isWhitespace)

public expect fun String.lowercase(): String
```
那么，Kotlin官方能不能将“字符操作方法”放到String类当中合并到一起呢？源代码是Kotlin官方写的，他们当然能将所有的代码都合并到一个类当中去，形成一个几千行的String类，但他们却没有这么做。这是为啥呢？

这就是Kotlin扩展的第一个典型使用场景：关注点分离。所谓关注点分离，就是将我们程序的逻辑划分成不同的部分，每一个部分，都只关注自己那部分的职责。以上面的String类为例，String.kt这个类，只关注String的核心逻辑；而Strings.kt则只关注String的操作符逻辑。

需要注意的是，只有借助Kotlin的扩展，我们才能实现这样的关注点分离设计。如果你去看Java的String类，你会发现它的源代码有三千多行。这是因为，Java的String核心属性跟它的操作方法全都混合在了一起。

第二个代码案例，是我工作当中用到的一段Android扩展函数代码：
```kotlin
inline fun  View.updateLayoutParams(block: T.() -> Unit) {
    val params = layoutParams as T
    block(params)
    layoutParams = params
}

fun View.updateMargin(left: Int? = null, top: Int? = null, right: Int? = null, bottom: Int? = null) {
    (layoutParams as? ViewGroup.MarginLayoutParams)?.let { param ->
        updateLayoutParams {
            left?.let {
                marginStart = left
            }

right?.let {
                marginEnd = right
            }

top?.let {
                topMargin = top
            }

bottom?.let {
                bottomMargin = bottom
            }
        }
    }
}
```
上面的代码定义了两个扩展函数，`updateLayoutParams()`、`updateMargin()`，后者的方法体当中用到了前者。通过`updateMargin()`这个扩展函数，可以大大简化Android当中的margin更新。
```kotlin
view.updateMargin(top = 100, bottom = 100)
```
而如果不借助扩展函数，我们将不得不写一堆的模板代码：
```kotlin
val params = view.layoutParams
if (params is ViewGroup.MarginLayoutParams) {
    params.marginTop = 100
    params.marginBottom = 100
    view.layoutParams = params
}
```
可以看到，借助扩展函数，我们不仅提升了代码的可读性，还提升了编码效率，而这种效率可以说是成倍的提升：借助扩展函数，我们只需要写一行代码，IntelliJ还会智能提示，帮我们补全代码；不借助扩展函数的话，我们需要写5行代码，这样的代码模式不仅枯燥繁琐，IntelliJ也无法智能提示，也更容易出错。

我们来小结一下，Kotlin扩展主要有两个核心使用场景。
- 主动使用扩展，通过它来优化软件架构。
对复杂的类进行职责划分，关注点分离。让类的核心尽量简单易懂，而让类的功能性属性与方法以扩展的形式存在于类的外部。比如我们的String.kt与Strings.kt。
- 被动使用扩展，提升可读性与开发效率。
当我们无法修改外部的SDK时，对于重复的代码模式，我们将其以扩展的方式封装起来，提供给对应的接收者类型，比如view.updateMargin()。

### 小结
好，让我们来做个简单的总结吧。

- Kotlin的扩展，从语法角度来看，分为扩展函数和扩展属性。定义扩展的方式，只是比普通函数、属性多了一个“扩展接收者”而已。
- 从作用域角度来看，分为顶层扩展和类内扩展。
- 从本质上来看，扩展函数和扩展属性，它们都是Java静态方法，与Java当中的工具类别无二致。对比Java工具类，扩展最大的优势就在于，IDE可以为我们提供代码补全功能。
- 从能力的角度来看，Kotlin扩展一共有三个限制，分别是：扩展无法被重写；扩展属性无法存储状态；扩展的作用域有限，无法访问私有成员。
- 从使用场景的角度来看，Kotlin扩展主要有两个使用场景，分别是：关注点分离，优化代码架构；消灭模板代码，提高可读性和开发效率。
最后在这里，我还想和你分享一下我在学Kotlin扩展的思考过程，希望这种思考的方式可以给你带来一些启发。

刚开始，我学习扩展的时候，脑子里其实是一片混乱的，就像下面这张图一样：扩展的每一个知识点都是散乱的。

这时候，我们就要将这些知识点做一个分类整理，同时，在学习扩展语法的时候，还要与前面的普通函数、普通属性的语法进行关联记忆。这样一来，我们零散的知识点就连接到一起，形成体系化的知识面。

![](/media/202410/2024-10-28_112212_8617250.40755269507617164.png)

当我们的知识形成一个体系之后，记忆起来就很容易了，这样，一个简单的浅层知识结构就形成了。

![](/media/202410/2024-10-28_112228_6970840.606979870055755.png)

接着，在这个基础上，我们再进行深度的思考，去探索扩展的底层原理，还有它的能力边界，从而形成一个更加深层次的知识结构。

![](/media/202410/2024-10-28_112250_1372130.21129175330965455.png)

到目前为止，这些都是理论层面的一些知识，我们还需要进一步探索Kotlin扩展的实际应用场景。这时候，就会发现它的两个主要使用场景，**一个是主动的，一个是被动的**。

![](/media/202410/2024-10-28_112305_3299010.21067899118516709.png)

其实，学习就是一个不断向下挖掘探索的过程。学习Kotlin是这样，学习其他计算机知识也是这样，甚至学习其他领域的知识也是这个道理。

### 思考题
在这节课中的所有案例中，我们的“扩展接收者”都是不为空的类型。但实际上，Kotlin的扩展是允许我们为“可为空的类型”进行扩展的。比如说：
```kotlin
// 不为空的接收者类型
//     ↓
fun String.lastElement(): Char? {}

// 可为空的接收者类型
//     ↓
fun String?.lastElement(): Char? {}
```
那么，请问这两种扩展有什么不同？欢迎在评论区分享你的思路，我们下节课再见。