扩展

所谓扩展，本质上就是为组件绑定新的监听器，实现自定义的属性或行为。

/**
 * 对MutableList进行基于泛型的扩展
 */
fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
    // this指向当前列表
    val tmp = this[index1]
    this[index1] = this[index2]
    this[index2] = tmp
}
class MyClass {}

/**
 * 扩展属性，得到MutableList的最后一个元素
 */
val <T> MutableList<T>.lastItem: T get() = this[this.lastIndex]?: throw NoSuchElementException()

/**
 * 伴生对象的扩展
 */
class MyClassCompanion {
    companion object {
    }
}
fun MyClassCompanion.Companion.hello(name: String) {
    println("hello $name")
}

/**
 * let扩展
 */
fun <T> T.myLet(block: (T) -> Unit): T {
    block(this)
    return this
}
fun test(name: String?) {
    // 避免数据为null的情况
    name?.myLet {
        println("$name is not null")
    }

    // 限制作用域
    val result = "hello".myLet {
        println("it -> $it")
        // 返回it
        it
    }
}

/**
 * run扩展
 */
data class Person(val name: String, val age: Int)
fun run(person: Person) {
    person.run {
        println("Person -> $name, $age")
    }
}

/**
 * apply扩展
 */
fun apply() {
    val list = mutableListOf(1, 2, 3)
    list.apply {
        // apply中得到的就是list本身
        add(4)
        add(5)
        println("list -> $this")
    }
}

fun main() {
    // 交换数字
    val list1 = mutableListOf(4, 2, 7)
    list1.swap(0, 2)
    println(list1)
    // 调用扩展属性
    println("list1.lastItem -> " + list1.lastItem)

    // 交换字符串
    val list2 = mutableListOf("a", "b", "c")
    list2.swap(0, 2)
    println(list2)
    // 调用扩展属性
    println("list2.lastItem -> " + list2.lastItem)

    // 交换类实例
    val list3 = mutableListOf(MyClass(), MyClass(), MyClass())
    println(list3)
    list3.swap(0, 2)
    println(list3)
    // 调用扩展属性
    println("list3.lastItem -> " + list3.lastItem)

    // 调用伴生对象的扩展函数
    MyClassCompanion.hello("lixingyun")

    // let扩展
    test("wanglin")
    // 如果为null则不打印
    test(null)

    // run扩展
    run(Person("xiaoyan", 18))

    // apply扩展
    apply()
}

---

感谢支持

更多内容，请移步《超级个体》。