Kotlin第八弹：Kotlin扩展

淡淡的烟草味﹌ 2024-04-06 12:58 120阅读 0赞

> **会一直坚持写关于Kotlin的入门系列文章，赶紧关注一起学习吧！**

**目录**

前言

1.扩展方法的原型

2.扩展方法的使用

二、原理解析：Kotlin扩展方法怎么实现的

三、泛型扩展方法

四、扩展属性

五、为伴生对象添加扩展

六、Kotlin 中常用的扩展

七、案例：使用 Kotlin 扩展为控件绑定监听器减少模板代码

总结

--------------------

## 前言 ##

在这一节为大家继续带来 Kotlin 中的一些高级的内容：Kotlin 中的 Kotlin 扩 展（Extensions）。

Kotlin 能够扩展一个类的新功能而无需继承该类。 例如，你可以为一个你不 能修改的来自第三方库中的类编写一个新的函数。 这个新增的函数就像那个 原始类本来就有的函数一样，可以用普通的方法调用。 这种机制称为 扩展 函数 。此外，也有 扩展属性 ， 允许你为一个已经存在的类添加新的属 性。想想是不是感觉很疯狂呢？那接下来就往我们开启这种疯狂吧。

--------------------

**一、扩展方法**

Kotlin 的扩展函数可以让你作为一个类成员进行调用的函数，但是是定义在这 个类的外部。这样可以很方便的扩展一个已经存在的类，为它添加额外的方 法。在 Kotlin 源码中，有大量的扩展函数来扩展 Java，这样使得 Kotlin 比 Java 更方便使用，效率更高。

#### 1.扩展方法的原型 ####

![06d5d039998c4acaa524105a228bbcf1.png][]

#### **2.扩展方法的使用** ####

**在 Kotlin 中使用**

class Jump {
     fun test() {
     println("jump test")
     //在被扩展的类中使用
     doubleJump(1f)
     }
    }
    fun Jump.doubleJump(howLong: Float): Boolean {
     println("jump:$howLong")
     println("jump:$howLong")
     return true
    }
    Jump().doubleJump(2f)
    //在被扩展类的外部使用
    Jump().test()

**在 Java 中使用**

在 Java 中调用 Kotlin 扩展，需要通过扩展所在的文件名+.的方式进行调用：

KotlinExtensionKt.doubleJump(new Jump(), 2.0f);

另外，需要注意的是我们需要为这个方法传递它被扩展类的对象来作为接受者，为什么要传递接 受者对象，这是由扩展的实现原理所决定的，在原理解析部分会讲解。

--------------------

## 二、原理解析：Kotlin扩展方法怎么实现的 ##

在体验到 Kotlin 扩展带个我们高效编程的同时，我们不禁要问自己几个问 题：

• Kotlin 的扩展是怎么实现的？

• Kotlin 的扩展会不是有性能问题？

接下来我们就从 Kotlin 反编译出 Java 代码上来一探究竟：

fun main() {
     val test = mutableListOf(1, 2, 3)
     test.swap(1, 2)
     println(test)
    }
    fun MutableList<Int>.swap(index1: Int, index2: Int) {
     val tmp = this[index1]
     this[index1] = this[index2]
    this[index2] = tmp
    }

反编译出 Java 源码

public final class KotlinExtensionKt {
     public static final void main() {
     List test = CollectionsKt.mutableListOf(new Integer[]{1, 2, 3});
     swap(test, 1, 2);
     boolean var1 = false;
     System.out.println(test);
     }
     // $FF: synthetic method
     public static void main(String[] var0) {
     main();
     }
     public static final void swap(@NotNull List $this$swap, int index1,
    int index2) {
     Intrinsics.checkParameterIsNotNull($this$swap, "$this$swap");
     int tmp = ((Number)$this$swap.get(index1)).intValue();
     $this$swap.set(index1, $this$swap.get(index2));
     $this$swap.set(index2, tmp);
     }
    }

从反编译出的 Java 源码分析，扩展函数的实现非常简单，它没有修改接受者类型的成员， 仅仅 是通过静态方法来实现的。所以我们不必担心扩展函数会带来额外的性能消耗。

--------------------

## 三、泛型扩展方法 ##

为了考虑到扩展函数的通用型，我们可以借助上面课程中学习到的泛型，来 为扩展方法进行泛型化改造，以 fun MutableList.swap(index1: Int, index2: Int)为例，接下来我们为它进行泛型化改造：

//泛型化扩展函数
    fun <T> MutableList<T>.swap1(index1: Int, index2: Int) {
     val tmp = this[index1]
     this[index1] = this[index2]
     this[index2] = tmp
    }
    val test2 = mutableListOf("Android Q", "Android N", "Android M")
    test2.swap1(0,1)
    println(test2)

--------------------

## 四、扩展属性 ##

扩展属性提供了一种方法能通过属性语法进行访问的 API 来扩展。尽管它们 被叫做属性，但是它们不能拥有任何状态，它不能添加额外的字段到现有的 Java 对象实例。

//为 String 添加一个 lastChar 属性，用于获取字符串的最后一个字符
    val String.lastChar: Char get() = this.get(this.length - 1)
    ///为 List 添加一个 last 属性用于获取列表的最后一个元素，this 可以省略
    val <T>List<T>.last: T get() = get(size - 1)
    val listString = listOf("Android Q", "Android N", "Android M")
    println("listString.last${listString.last}")

--------------------

## 五、为伴生对象添加扩展 ##

如果一个类定义了伴生对象 ，那么我们也可以为伴生对象定义扩展函数与属性：

class Jump {
     companion object {}
    }
    fun Jump.Companion.print(str: String) {
     println(str)
    }
    Jump.print("伴生对象的扩展")

就像伴生对象的常规成员一样：可以只使用类名作为限定符来调用伴生对象 的扩展成员；

## 六、Kotlin 中常用的扩展 ##

在 Kotlin 的源码中定义了大量的扩展，比如：let,run,apply，了解并运用这些 函数能帮我们提高编码效率，接下来就往我们一起揭开这些扩展函数的神秘面纱吧！

**let 扩展**

函数原型：

fun <T, R> T.let(f: (T) -> R): R = f(this)

let 扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，那么let 函数是一个不错的选择；let 函数另一个作用就 是可以避免写一些判断 null 的操作。

fun testLet(str: String?) {
     //限制 str2 的作用域
     str.let {
     val str2 = "let 扩展"
     println(it + str2)
     }
    // println(str2)//报错
     //避免为 null 的操作
     str?.let {
     println(it.length)
     }
    }

**run 扩展**

函数原型：

fun <T, R> T.run(f: T.() -> R): R = f()

run 函数只接收一个 lambda 函数为参数，以闭包形式返回，返回值为最后一 行的值或者指定的 return 的表达式，**在 run 函数中可以直接访问实例的公有属性和方法**。

data class Room(val address: String, val price: Float, val size: Float)
    fun testRun(room: Room) {
     room.run {
     println("Room:$address,$price,$size")
     }
    }

**apply 扩展**

函数原型：

fun <T> T.apply(f: T.() -> Unit): T { f(); return this }

apply 函数的作用是：调用某对象的 apply 函数，在函数范围内，可以任意调 用该对象的任意方法，并返回该对象。

从结构上来看 apply 函数和 run 函数很像，唯一不同点就是它们各自返回的 值不一样，run 函数是以闭包形式返回最后一行代码的值，而 apply 函数的返 回的是传入对象的本身。

apply 一般用于一个对象实例初始化的时候，需要对对象中的属性进行赋值。 或者动态 inflate 出一个 XML 的 View 的时候需要给 View 绑定数据也会用 到，这种情景非常常见。

fun testApply() {
     ArrayList<String>().apply {
     add("testApply")
     add("testApply")
     add("testApply")
     println("$this")
     }.let { println(it) }
    }

--------------------

## 七、案例：使用 Kotlin 扩展为控件绑定监听器减少模板代码 ##

定义扩展

//为 Activity 添加 find 扩展方法，用于通过资源 id 获取控件
    fun <T : View> Activity.find(@IdRes id: Int): T {
     return findViewById(id)
    }
    //为 Int 添加 onClick 扩展方法，用于为资源 id 对应的控件添加 onClick 监听
    fun Int.onClick(activity: Activity, click: () -> Unit) {
     activity.find<View>(this).apply {
     setOnClickListener {
     click()
     }
     }
    }

应用扩展

class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
     setContentView(R.layout.activity_main)
     val textView = find<TextView>(R.id.test)
     R.id.test.onClick(this) {
     textView.text = "Kotlin 泛型"
     }
     }
    }

在这个案例中我们通过两个扩展方法，大大减少了我们在获取控件，以及为 控件绑定 onClick 监听时候的模板代码，而且代码可读性更高，更加直观， 这便是 Kotlin 扩展的强大之处。

Kotlin 扩展的应用案例远不止这些，需要大家在下去之后能够活学活用，来发 掘属于你自己的 Kotlin 扩展吧。

--------------------

## 总结 ##

**这部分内容可能稍微有点难度，但还是可以接受的，加油啊！**

[06d5d039998c4acaa524105a228bbcf1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/1faa3c1a33274ba5b77aa7d56b0f439a.png