---

KotLin 相关文档

官方在线Reference
kotlin-docs.pdf
Kotlin for android Developers 中文翻译
Kotlin开发工具集成，相关平台支持指南
Kotlin开源项目与Libraries
Kotlin开源项目、资源、书籍及课程搜索平台
Google’s sample projects written in Kotlin
Kotlin and Android

 

---

类的扩展

在Kotlin中，可以自行对类进行扩展；不管是否是系统类
可以对类扩展函数与属性

---

扩展函数

扩展函数的语法：在方法前加上"classType."，如扩展 MutableList<Int> 类，增加一个名为swap的函数：

fun MutableList<Int>.swap(index1: Int, index2: Int) {val tmp = this[index1]this[index1] = this[index2]this[index2] = tmp
}

注意：扩展函数的影响范围

如果扩展函数定义在kotlin-file中，且是public的，则会影响它所处package中的其它类

如需要在其它package中的kotlin-file或kotlin-class中进行使用，需要进行import：import package.swap

如果定义在一个类中，那么只能在该类中使用

调用swap()：

fun main(args: Array<String>) {val list = mutableListOf(1, 3, 2)list.swap(1, 2)list.forEach(::println)
}

结合泛型参数的扩展函数

如下，使用泛型参数，它就能匹配：使用任意类型的MutableList

fun <T> MutableList<T>.swap2(index1: Int, index2: Int) {val tmp = this[index1]this[index1] = this[index2]this[index2] = tmp
}

基类与子类扩展同名函数

如下，C、D都扩展了一个foo()：

open class C
class D: C()
fun C.foo() = "c"  //为class C 扩展 函数 foo
fun D.foo() = "d"  //为class D 扩展 函数 foo
fun printFoo(c: C) {println(c.foo())
}
printFoo(D())

本例，最终会输出 “c”。
因为基类与子类，扩展了同名函数且参数类型相同， 并不会自动 override, 所以会输出 “c”

对目标类扩展同名函数

class E {fun foo() { println("member") }fun fooX(arg: Int) { println("member: $arg") }
}
fun E.foo() { println("extension") }
fun E.fooX(v: Int) { println("extension: $v") }

扩展函数与原类的成员，如果函数名、参数类型相同， 则原成员函数胜出
所以，

E().foo() //print  member
E().fooX(3) //print  member: 3

---

扩展属性

与扩展函数类似，扩展属性的语法：在属性前加上"classType."

如下，对任意类型的List，添加只读属性 lastIndex

 val <T> List<T>.lastIndex: Int get() = size - 1

注意：扩展的属性，并没有在实际上插入到原有类中，所以扩展属性，没有一个有效的 “backing field” (即在getter/setter方法使用’filed’关键字)，也就不能直接初始化，而需要显式的指定 getter/setter方法

如下，扩展属性时直接初始化，会报错：

val Foo.bar = 1 // error: initializers are not allowed for extension properties

---

对companion对象进行函数和属性的扩展

关于companion object， 其实就是声明一个类似java的静态内部类，名为Companion。Kotlin中支持调用Companion的属性和函数时，可以直接使用 [外部类名.func/property]，即省略Companion类名

例如，

class MyClass {
companion object { } // will be called "Companion"
}
fun MyClass.Companion.foo() { // ...
}
fun main() {MyClass.foo()
}

---

声明扩展元素为类的成员

扩展函数中调用的元素，既在被扩展类中，也在外部类中

class DM {fun bar() {}
}
class DN {fun baz() {}/*在class 中 声明 DM类的 扩展函数*/fun DM.foo() {bar() //DM barbaz() //DN baz}override fun toString(): String {return "DN"}/*在扩展函数中 调用 外部类的 函数 this@classthis.method()  会调用 被扩展类的*/fun DM.to() {toString()this.toString() //这和上一句是一样的， 调用的是DM的this@DN.toString() //调用DN的}
}

同时对基类与子类扩展相同的元素

open class DE
open class DF: DE()
open class CE {open fun DE.foo() {println("DE.foo in CE")}open fun DF.foo() {println("DF.foo in CE")}fun called(de: DE) {de.foo()}
}
class CF: CE() {override fun DE.foo() {println("DE.foo1 in CF")}override fun DF.foo() {println("DF.foo1 in CF")}
}fun main(args: Array<String>) {CE().called(DE())  //DE.foo in CECE().called(DF())  //DF、DE扩展的相同的方法； 子类扩展无效的。所以 DE.foo in CECF().called(DE())  //DE.foo in CFCF().called(DF())  //DE.foo in CF
}

如上，会输出：

DE.foo in CE
DE.foo in CE
DE.foo1 in CF
DE.foo1 in CF

可见，同时对基类与子类扩展相同的元素，基类胜出

---