Kotlin的标准函数指的是Standard.kt文件中定义的函数,任何Kotlin代码都可以自由地调用所有的标准函数

let这个标准函数已经学过了
它的主要作用就是配合?.操作符来进行辅助判空处理

标准函数 with

with函数接收两个参数:
第—个参数可以是—个任意类型的对象,
第二个参数是—个Lambda表达式

with函数会在Lambda表达式中提供第—个参数对象的上下文,
并使用Lambda表达式中的最后—行代码作为返回值返回。

示例代码如下:

    val result = with(obj) {
        // 这里是obj的上下文
        "value" // with函数的返回值
    }

它可以在连续调用同—个对象的多个方法时让代码变得更加精简

有—个水果列表,拼接在一起并将结果打印出来。普通写法

    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
    val result = with(StringBuilder()) {
        append("One:Start eating fruits.")
        for (fruit in list) {
            append(fruit).append("-")
        }
        append("Ate all fruits.")
        toString()
    }
    println(result)

with写法

    val result = with(StringBuilder()) {
        append("Start eating fruits.\n")
        for (fruit in list) {
            append(fruit).append("\n")
        }
        append("Ate all fruits.")
        toString()
    }
    println(result)

with函数的第—个参数传入了—个StringBuilder对象,
那么接下来整个Lambda表达式的上下文就会是这个StringBuilder对象。
于是我们在Lambda表达式中就不用再像刚才那样调用builder.append()和builder.toString()方法了,
而是可以直接调用append()和toString()方法。
Lambda表达式的最后—行代码会作为with函数的返回值返回

标准函数 run

run函数通常不会直接调用,而是要在某个对象的基础上调用;
其次run函数只接收—个Lambda参数,并且会在Lambda表达式中提供调用对象的上下文

    val result = obj.run {
        // 这里是obj的上下文
        "value" // run函数的返回值
    }

run写法

    val result2 = StringBuilder().run {
        append("Two:Start eating fruits.")
        for (fruit in list) {
            append(fruit).append("-")
        }
        append("Ate all fruits.")
        toString()
    }
    println(result2)

标准函数 apply

apply函数和run函数也是极其类似的,
都要在某个对象上调用,
并且只接收一个Lambda参数,也会在Lambda表达式中提供调用对象的上下文,
但是apply函数无法指定返回值,而是会自动返回调用对象本身。

    val result = obj.apply {
        // 这里是obj的上下文
    }
    // result == obj

apply写法：

    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
    val sb = StringBuilder().apply {
        append("Three:Start eating fruits.")
        for (fruit in list) {
            append(fruit).append("-")
        }
        append("Ate all fruits.")
    }
    println(sb.toString())

由于apply函数无法指定返回值,只能返回调用对象本身,因此这里的result实际上是一个StringBuilder对象

定义静态方法

静态方法在某些编程语言里面又叫作类方法,指的就是那种不需要创建实例就能调用的方法

和绝大多数主流编程语言不同的是,Kotlin却极度弱化了静态方法这个概念,想要在Kotlin中定义一个静态方法反倒不是一件容易的事。
那么Kotlin为什么要这样设计呢?因为Kotlin提供了比静态方法更好用的语法特性,并且我们在上一节中已经学习过了,那就是单例类。

像工具类这种功能,在Kotlin中就非常推荐使用单例类的方式来实现

object Util {

    fun doAction() {
        println("do action")
    }

}

虽然这里的doAction()方法并不是静态方法,
但是我们仍然可以使用Util.doAction()的方式来调用,
这就是单例类所带来的便利性

使用单例类的写法会将整个类中的所有方法全部变成类似于静态方法的调用方式,
而如果我们只是希望让类中的某一个方法变成静态方法的调用方式该怎么办呢？

class Util2 {
    fun doAction1() {
        println("do action")
    }

    companion object {
        fun doAction2() {
            println("do action2")
        }
    }
}

doAction1()方法是一定要先创建Util类的实例才能调用的,
doAction2()方法可以直接使用Util.doAction2()的方式调用。

doAction2()方法其实也并不是静态方法,
companion object这个关键字实际上会在Util类的内部创建一个伴生类,
而doAction2()方法就是定义在这个伴生类里面的实例方法。
只是Kotlin会保证Util类始终只会存在一个伴生类对象,
因此调用Util.doAction2()方法实际上就是调用了Util类中伴生对象的doAction2()方法。

Kotlin确实没有直接定义静态方法的关键字,但是提供了一些语法特性来支持类似于静态方法调用的写法
如果你确实需要定义真正的静态方法, Kotlin仍然提供了两种实现方式:注解和顶层方法

如果我们给单例类或companion object中的方法加上@JvmStatic注解,
那么Kotlin编译器就会将这些方法编译成真正的静态方法

class Util2 {
//    @JvmStatic error
    fun doAction1() {
        println("do action")
    }

    companion object {
        @JvmStatic
        fun doAction2() {
            println("do action2")
        }

    }
}

顶层方法指的是那些没有定义在任何类中的方法
Kotlin编译器会将所有的顶层方法全部编译成静态方法,因此只要你定义了—个顶层方法,那么它就—定是静态方法。

fun doSomething() {
    println("do something")
}

但如果是在Java代码中调用,你会发现是找不到doSomething()这个方法的,因为Java中没有顶层方法这个概念,所有的方法必须定义在类中。那么这个doSomething()方法被藏在了哪里呢?
我们刚才创建的Kotlin文件名叫作Helper.kt,于是Kotlin编译器会自动创建—个叫作HelperKt的Java类,doSomething()方法就是以静态方法的形式定义在HelperKt类里面的,因此在Java中使用HelperKt.doSomething()的写法来调用就可以了