Kotlin笔记（扩展）

　　Kotlin 提供了对一个类扩展新功能的能力，而无需从类继承或使用 Decorator 等设计模式。这是通过称为 扩展 的特殊声明完成的。例如，您可以为无法修改的第三方库中的类编写新函数。可以以通常的方式调用此类函数，就好像它们是原始类的方法一样。这种机制称为 扩展功能 。您也可以为现有的类扩展新的属性。
　　扩展功能
　　要声明扩展函数，请在其名称前加上 接收器类型 ，它指的是被扩展的类型。以下为MutableList添加了一个swap函数： fun MutableList.swap(index1: Int, index2: Int) {     val tmp = this[index1] // ＂this＂ corresponds to the list     this[index1] = this[index2]     this[index2] = tmp }
　　扩展函数中的关键字this对应于接收器对象（在点之前传递的对象）。现在，您可以在 任何MutableList对象上调用这样的函数： val list = mutableListOf(1, 2, 3) list.swap(0, 2) // ＂this＂ inside ＂swap()＂ will hold the value of ＂list＂
　　此函数对任何MutableList对象都有意义，您还可以在其中加入泛型： fun  MutableList.swap(index1: Int, index2: Int) {     val tmp = this[index1] // ＂this＂ corresponds to the list     this[index1] = this[index2]     this[index2] = tmp }
　　您需要在函数名称之前声明泛型类型参数，以使其在接收器类型表达式中可用。有关泛型的更多信息，请参阅 泛型函数。
　　扩展是静态解析的
　　扩展实际上并不修改它们所扩展的类。通过定义扩展，您不会将新成员插入到类中，而只是使新函数可以使用这种类型的变量的点符号调用。扩展函数是 静态 调度的，被调用的扩展函数是由调用函数的 接收器 类型所对应的 表达式 的决定，而不是由在运行时计算该表达式的结果类型决定。例如： fun main() {     open class Shape     class Rectangle: Shape()      fun Shape.getName() = ＂Shape＂     fun Rectangle.getName() = ＂Rectangle＂      fun printClassName(s: Shape) {         println(s.getName())     }      printClassName(Rectangle()) } 输出：Shape
　　此示例打印 Shape ，因为调用的扩展函数仅取决于参数的声明类型s，即Shape类。
　　如果一个类有一个成员函数，并且定义了一个具有相同接收器类型、相同名称并且适用于给定参数的扩展函数，则成员函数的优先级更高。例如： class Example {     fun printFunctionType() { println(＂Class method＂) } }  fun Example.printFunctionType() { println(＂Extension function＂) }  Example().printFunctionType()  输出：Class method
　　但是，扩展函数完全可以重载同名但签名不同的成员函数： class Example {     fun printFunctionType() { println(＂Class method＂) } }  fun Example.printFunctionType(i: Int) { println(＂Extension function #$i＂) }  Example().printFunctionType(1)  输出：Extension function #1
　　可空接收器
　　请注意，可以使用可为空的接收器类型定义扩展。即使对象变量的值为空，也可以在对象变量上调用这些扩展，并且可以扩展函数内部检查this == null。这样，您可以在不检查null的情况下调用toString()，因为检查发生在扩展函数内部： fun Any?.toString(): String {     if (this == null) return ＂null＂     // after the null check, ＂this＂ is autocast to a non-null type, so the toString() below     // resolves to the member function of the Any class     return toString() }
　　扩展属性
　　Kotlin 支持扩展属性，就像它支持函数一样： val  List.lastIndex: Int     get() = size - 1
　　由于扩展实际上并不将成员插入到类中，因此扩展属性没有有效的方法来拥有 支持字段。这就是 扩展属性不允许使用初始化程序的 原因。它们的行为只能通过显式提供 getter/setter 来定义。 val House.number = 1 // error: initializers are not allowed for extension properties
　　伴随对象的扩展
　　如果一个类定义了 伴随对象，您还可以为伴随对象定义扩展函数和属性。就像 伴随对象的常规成员一样，它们可以仅使用类名作为限定符来调用： class MyClass {     companion object { }  // will be called ＂Companion＂ }  fun MyClass.Companion.printCompanion() { println(＂companion＂) }  fun main() {     MyClass.printCompanion() }
　　扩展的范围
　　在大多数情况下，您在顶层定义扩展，直接在包下： package org.example.declarations  fun List.getLongestString() { /*...*/}
　　要在其声明包之外使用扩展，请在调用站点将其导入： package org.example.usage  import org.example.declarations.getLongestString  fun main() {     val list = listOf(＂red＂, ＂green＂, ＂blue＂)     list.getLongestString() }
　　将扩展声明为成员
　　您可以在一个类中声明另一个类的扩展。在这样的扩展中，有多个 隐式接收器 - 其成员可以在没有限定符的情况下访问的对象。声明扩展的类的实例称为 调度接收器 ，扩展方法的接收器类型的实例称为 扩展接收器 。 class Host(val hostname: String) {     fun printHostname() { print(hostname) } }  class Connection(val host: Host, val port: Int) {     fun printPort() { print(port) }      fun Host.printConnectionString() {         printHostname()   // calls Host.printHostname()         print(＂:＂)         printPort()   // calls Connection.printPort()     }      fun connect() {         /*...*/         host.printConnectionString()   // calls the extension function     } }  fun main() {     Connection(Host(＂kotl.in＂), 443).connect()     //Host(＂kotl.in＂).printConnectionString()  // error, the extension function is unavailable outside Connection }  输出：kotl.in:443
　　如果调度接收器和扩展接收器的成员之间发生名称冲突，则扩展接收器优先。要引用调度接收者的成员，您可以使用 限定的this语法。 class Connection {     fun Host.getConnectionString() {         toString()         // calls Host.toString()         this@Connection.toString()  // calls Connection.toString()     } }
　　声明为成员的扩展可以声明为open并在子类中覆盖。这意味着此类函数的调度对于调度接收器类型是虚拟的，但对于扩展接收器类型是静态的。 open class Base { }  class Derived : Base() { }  open class BaseCaller {     open fun Base.printFunctionInfo() {         println(＂Base extension function in BaseCaller＂)     }      open fun Derived.printFunctionInfo() {         println(＂Derived extension function in BaseCaller＂)     }      fun call(b: Base) {         b.printFunctionInfo()   // call the extension function     } }  class DerivedCaller: BaseCaller() {     override fun Base.printFunctionInfo() {         println(＂Base extension function in DerivedCaller＂)     }      override fun Derived.printFunctionInfo() {         println(＂Derived extension function in DerivedCaller＂)     } }  fun main() {     BaseCaller().call(Base())   // ＂Base extension function in BaseCaller＂     DerivedCaller().call(Base())  // ＂Base extension function in DerivedCaller＂ - dispatch receiver is resolved virtually     DerivedCaller().call(Derived())  // ＂Base extension function in DerivedCaller＂ - extension receiver is resolved statically }
　　注意可见性
　　扩展使用与在相同范围内声明的常规函数 相同的可见性修饰符。例如： 在文件顶层声明的扩展可以访问同一文件中的其他顶层声明。 如果扩展在其接收者类型之外声明，则它不能访问接收者的private或protected成员。