Kotlin 扩展
Kotlin 可以对一个类的属性和方法进行扩展,且不需要继承。
扩展是一种静态行为,对被扩展的类代码本身不会造成任何影响。
类的扩展,是什么鬼?反正我学java是没有见过,下面看看Kotlin中的扩展吧。
一.扩展方法
就是添加方法。
1.扩展方法可以在已有类中添加新的方法,不会对原类做修改,扩展方法定义形式:
fun receiverType.functionName(params){
// body 方法体
}
receiverType:表示方法的接收者,也就是方法扩展的对象,也就是类名!
functionName:扩展方法的名称
params:扩展方法的参数,可以为NULL
注意上面三个都不是关键字,是象征的名词。
2.以下实例扩展 User 类 :
class User(var name:String)
/**扩展方法**/
fun User.Print(){
print("用户名 $name")
}
fun main(arg:Array<String>){
var user = User("Runoob")
user.Print()
}
实例执行输出结果为:
用户名 Runoob
3.下面代码为 MutableList 添加一个swap 方法:
package hello // 可选的包头
// 扩展方法 swap,调换不同位置的值
fun MutableList<Int>.swap(index1: Int, index2: Int) {
val tmp = this[index1] // this 对应该列表
this[index1] = this[index2]
this[index2] = tmp
}
fun main(args: Array<String>) {
val l = mutableListOf(1, 2, 3)
println(l.toString())
// 位置 0 和 2 的值做了互换
l.swap(0, 2) // 'swap()' 方法内的 'this' 将指向 'l' 的值
println(l.toString())
}
实例执行输出结果为:
[1, 2, 3]
[3, 2, 1]
上面MutableList是系统的集合类,java中虽然没有这个类,但是有很多类似的集合类。
this关键字指代接收者对象(receiver object)(也就是调用扩展方法时, 在点号之前指定的对象实例)。也就是类本身的对象。
二.扩展方法是静态解析的
1.扩展方法是静态解析的
并不是接收者类型的虚拟成员,在调用扩展方法时,具体被调用的的是哪一个方法,由调用方法的的对象表达式来决定的,而不是动态的类型决定的:
open class C //定义可以被继承的类C
class D: C() //定义类D
fun C.foo() = "c" // 扩展方法 foo
fun D.foo() = "d" // 扩展方法 foo
fun printFoo(c: C) {
println(c.foo()) // 类型是 C 类
}
fun printFoo(d: D) {
println(d.foo()) // 类型是 D类
}
fun main(arg:Array<String>){
printFoo(D()) //打印d
printFoo(C()) //打印c
}
实例执行输出结果为:
d
c
这里子类和父类方法重复,扩展方法是都是后面添加上去的,不会发生方法覆盖的情况,子类对象执行的是子类的方法,父类对象执行的是父类的方法。
2.若扩展方法和成员方法一致,则使用该方法时,会优先使用成员方法。
class C {
fun foo() { println("成员方法") }
}
fun C.foo() { println("扩展方法") }
fun main(arg:Array<String>){
var c = C()
c.foo()
}
实例执行输出结果为:
成员方法
这里如果类原本的方法和扩展方法相同,相当于扩展方法没有用!
三.扩展一个空对象
1.在扩展方法内, 可以通过 this 来判断接收者是否为 NULL,这样,即使接收者为 NULL,也可以调用扩展方法。
例如:
fun Any?.toString(): String {
if (this == null) return "null"
// 空检测之后,“this”会自动转换为非空类型,所以下面的 toString()
// 解析为 Any 类的成员方法
return toString()
}
fun main(arg:Array<String>){
var t = null
println(t.toString())
var t2 = 505
println(t2.toString())
}
上面好像很吊的样子,居然扩展了系统的类Any,类似于Java 的Object。
如果把一下系统类的方法替换了,其他地方没有注意的话,会不会有Bug!所以建议少去改系统类的方法!
实例执行输出结果为:
null
505
2.扩展属性
除了方法,Kotlin 也支持属性对属性进行扩展:
val <T> List<T>.lastIndex: Int
get() = size - 1
扩展属性允许定义在类或者kotlin文件中,不允许定义在方法中。
初始化属性因为属性没有后端字段(backing field),所以不允许被初始化,只能由显式提供的 getter/setter 定义。
val Foo.bar = 1 // 错误:扩展属性不能有初始化器
扩展属性只能被声明为 val。
四.伴生对象的扩展
如果一个类定义有一个伴生对象 ,你也可以为伴生对象定义扩展方法和属性。
伴生对象通过”类名.”形式调用伴生对象,伴生对象声明的扩展方法,通过用类名限定符来调用:
class MyClass {
companion object { } // 将被称为 "Companion"
}
fun MyClass.Companion.foo() { //给伴生对象扩展方法
println("伴随对象的扩展方法")
}
val MyClass.Companion.no: Int //给伴生对象扩展属性
get() = 10
fun main(args: Array<String>) { //调用伴生对象的属性和方法
println("no:${MyClass.no}")
MyClass.foo()
}
注意上面companion是关键字,Companion也是关键字,并且他们的使用不能随意搞错!
实例执行输出结果为:
no:10
伴随对象的扩展方法
五.扩展的作用域
通常扩展方法或属性定义在顶级包下:
package foo.bar
fun Baz.goo() { …… }
要使用所定义包之外的一个扩展, 通过import导入扩展的方法名进行使用:
package com.example.usage
import foo.bar.goo // 导入所有名为 goo 的扩展
// 或者
import foo.bar.* // 从 foo.bar 导入一切
fun usage(baz: Baz) {
baz.goo()
}
六.扩展声明为成员
1.在一个类内部你可以为另一个类声明扩展。
在这个扩展中,有个多个隐含的接受者,其中扩展方法定义所在类的实例称为分发接受者,而扩展方法的目标类型的实例称为扩展接受者。
class D { //定义类D
fun bar() { println("D bar") }
}
class C { //定义类C
fun baz() { println("C baz") }
fun D.foo() { //扩展类D的方法
bar() // 调用 D.bar
baz() // 调用 C.baz
}
fun caller(d: D) {
d.foo() // 调用扩展方法
}
}
//测试
fun main(args: Array<String>) {
val c: C = C()
val d: D = D()
c.caller(d)
}
实例执行输出结果为:
D bar
C baz
在 C 类内,创建了 D 类的扩展。
此时,C 被成为分发接受者,而 D 为扩展接受者。
从上例中,可以清楚的看到,在扩展方法中,可以调用派发接收者的成员方法。
2.假如在调用某一个方法,而该方法在分发接受者和扩展接受者均存在,则以扩展接收者优先,要引用分发接收者的成员你可以使用限定的 this 语法。
class D {
fun bar() { println("D bar") }
}
class C {
fun bar() { println("C bar") } // 与 D 类 的 bar 同名
fun D.foo() {
bar() // 调用 D.bar(),扩展接收者优先
this@C.bar() // 调用 C.bar()
}
fun caller(d: D) {
d.foo() // 调用扩展方法
}
}
fun main(args: Array<String>) {
val c: C = C()
val d: D = D()
c.caller(d)
}
这个和java类似,如果方法内的属性和类的属性冲突,要调用类的属性就要用this声明。
实例执行输出结果为:
D bar
C bar
3.以成员的形式定义的扩展方法, 可以声明为 open , 而且可以在子类中覆盖.
也就是说, 在这类扩展方法的派 发过程中, 针对分发接受者是虚拟的(virtual), 但针对扩展接受者仍然是静态的。
open class D { //定义类D
}
class D1 : D() {//定义类D1
}
open class C { //定义类C
open fun D.foo() { //扩展类D,添加方法foo
println("D.foo in C")
}
open fun D1.foo() { //扩展类D1,添加方法foo
println("D1.foo in C")
}
fun caller(d: D) {
d.foo() // 调用扩展方法
}
}
class C1 : C() { //定义类C1
override fun D.foo() { //重写类D的扩展方法
println("D.foo in C1")
}
override fun D1.foo() { //重写类D1的扩展方法
println("D1.foo in C1")
}
}
//测试
fun main(args: Array<String>) {
C().caller(D()) // 输出 "D.foo in C"
C1().caller(D()) // 输出 "D.foo in C1" —— 分发接收者虚拟解析
C().caller(D1()) // 输出 "D.foo in C" —— 扩展接收者静态解析
}
上面的过程可以看详细点。
注意caller方法是父类C的方法。
实例执行输出结果为:
D.foo in C
D.foo in C1
D.foo in C
Kotlin的扩展,一个奇葩的东西,就学习到这里的。
有兴趣的可以在线测试一下,多个类一样可以在线测试的。
https://blog.csdn.net/wenzhi20102321/article/details/79859347