kotlin之扩展

短命女 2023-01-09 14:16 79阅读 0赞

# 扩展类 #

通常要对一个类进行扩展，可以使用继承或者设计模式如装饰者模式，kotlin中提供了另外一种方法：extension。

## 扩展方法 ##

为一个类添加方法：

package com.morris.kotlin.extension
    
    fun <T> MutableList<T>.swap(from: Int, to: Int) { 
        var temp = this[from]
        this[from] = this[to]
        this[to] = temp
    }
    
    fun main() { 
        var list = mutableListOf(1, 2, 3)
        list.swap(0, 2)
        println(list)
    }

## 扩展是被静态解析的 ##

扩展功能并没有实际修改类，并没有往类的字节码中插入新的成员，仅仅只是让这个新的成员可以通过类的变量进行访问，看起来像类的成员一样。

扩展是被静态解析的，而不像多态一样动态解析，也就说调用具体哪个类的方法取决于声明参数的类型，而不是运行时参数的实际类型。

package com.morris.kotlin.extension
    
    open class Shape
    
    class Rectangle: Shape()
    
    fun Shape.getName() = "Shape"
    
    fun Rectangle.getName() = "Rectangle"
    
    fun printClassName(s: Shape) { 
        println(s.getName())
    }
    
    fun main() { 
        printClassName(Shape()) // Shape
        printClassName(Rectangle()) // Shape
    }

如果一个类有一个成员方法，并且扩展的方法签名一样，那么类中的方法优先，重载的方法可以实现增强。

class Example { 
        fun printFunctionType() {  println("Class method") }
    }
    
    fun Example.printFunctionType() {  println("Extension function") }
    
    fun Example.printFunctionType(i: Int) {  println("Extension function") }
    
    fun main() { 
        Example().printFunctionType() // Class method
        Example().printFunctionType(1) // Extension function
    }

## 可空的接收者 ##

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()
    }

## 扩展属性 ##

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

以下语法并不支持：

val House.number = 1 // error: initializers are not allowed for extension properties

不能直接扩展属性，只能扩展属性对应的setter和getter，因为属性最终的表现形式为setter和getter。

## 伴生对象扩展 ##

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

## 扩展的作用域 ##

前面介绍的扩展都是定义在顶层，其实也可以将一个类的扩展作为成员定义在另一个类的内部。

扩展函数定义所在的类的实例称为分发接收者（dispatch receiver），扩展函数所扩展的那个类称为扩展接收者（extension receiver）。

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(443) // error, the extension function is unavailable outside Connection
    }

如果分发接收者和扩展接收者中方法的名字出现冲突，扩展接收者的优先级高。

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"
        BaseCaller().call(Derived())   // "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
    }