Kotlin - 标准函数 with、run 、apply和静态方法

目录

1、标准函数 with、run 、apply

（1）with 函数

（2）run 函数

（3）apply 函数

2、定义静态方法

（1）单例类object

（2）companion object

（3）注解和顶层方法

① 注解

② 顶层方法

---

1、标准函数 with、run 、apply

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

（1）with 函数

        with 函数接收两个参数：第一个参数可以是一个任意类型的对象，第二个参数是一个 Lambda 表达式。with 函数会在 Lambda 表达式中提供第一个参数对象的上下文，并使用 Lambda 表达式中的最后一行代码作为返回值返回。

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

        with 函数可以在连续调用同一个对象的多个方法时，让代码变得更加精简。

例子：吃完一个水果列表

val list = listOf("Apple","Banana","Orange","Pear","Grape")
val builder = StringBuilder()
builder.append("Strat eating fruits.\n")

for(fruit in list){
    builder.append(fruit).append("\n")
}

builder.append("Ate all fruits.")
val result = builder.toString()
println(result)

调用了很多次builder 对象的方法，考虑用 with 函数让代码变得更加精简。

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

（2）run 函数

run函数的用法和使用场景和with函数非常类似，

① run 函数不能直接调用，一定要调用某个对象的 run 函数才行；

② run 函数只接收一个 Lambda 参数，并且会在 Lambda 表达式中提供调用对象的上下文。

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

val list = listOf("Apple","Banana","Orange","Pear","Grape")
val result = StringBuilder().run{
    append("Strat eating fruits.\n")
    for(fruit in list){
    	append(fruit).append("\n")
	}
	append("Ate all fruits.")
    toString()
}
println(result)

（3）apply 函数

apply 函数和 run 函数也极其类似，但 apply 函数无法指定返回值，而是会自动返回调用对象本身。

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

val list = listOf("Apple","Banana","Orange","Pear","Grape")
val result = StringBuilder().apply{
    append("Strat eating fruits.\n")
    for(fruit in list){
    	append(fruit).append("\n")
	}
	append("Ate all fruits.")
}
println(result.toString())

        由于 apply 函数无法指定返回值，只能返回调用对象本身，因此这里的 result 实际上是一个 StringBuilder 对象，所以我们在最后打印的时候还要再调用它的 toString( ) 方法才行。

2、定义静态方法

（1）单例类object

        静态方法在某些编程语言又叫做类方法，指的就是那种不需要创建实例就能调用的方法。在kotlin 中可以使用单例类（关键字 object）的写法，将整个类中的某一个方法变成静态方法的调用方法。

（2）companion object

        但如果只希望让类中的某一个方法变成静态方法，就可以使用 companion object。

class Util{
    fun doAction1(){
        println("do action1")
    }

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

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

（3）注解和顶层方法

定义真正的静态方法，Kotlin提供两种实现方式：注解和顶层方法。

① 注解

        给单例类或companion object 中的方法加上 @JvmStatic 注解，那么Kotlin 编译器就会将这些方法编译成真正的静态方法。@JvmStatic 注解只能加在单例类或 companion object 中的方法上，如果你尝试加在一个普通方法上，会直接提示语法错误。

class Util{
    fun doAction1(){
        println("do action1")
    }

    companion object{

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

② 顶层方法

        顶层方法指的是那些没有定义在任何类中的方法，Kotlin 编译器会将所有的顶层方法全部编译成静态方法。

        定义一个顶层方法：创建一个Kotlin 文件，对任意包右键 --> New --> Kotlin

File/Class --> 在弹出的对话框输入文件名即可，创建类型选择 File --> OK

        在kotlin中所有的顶层方法都可以在任何位置被直接调用，直接输入方法名( )；

        但是在 java 没有顶层方法概念，如果创建名字为 Helper.kt 的 Kotlin 文件，Kotlin 编译器会自动创建一个叫做 Helper 的 java 类，文件里的方法就是以静态方法的形式定义在 Helper类里面的，用 Helper.方法名( ) 调用。