第一行代码第三版笔记（第三章kotlin部分）

标准函数with、run和apply

with
with函数能够精简代码。接受两个参数，一个是任意类型的对象，另一个是lambda表达式。With函数会在Lambda表达式中提供第一个参数对象的上下文，并将该表达式最后一行代码作为返回值返回。

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

//StringBuilder构建吃水果的字符串，最后将结果打印出来。
fun eatfruits() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
    var builder = StringBuilder()
    builder.append("Starting eat fruit\n")
    for (fruit in list) {
        builder.append(fruit).append("\n")
    }
    builder.append("Ate all fruits.")
    val result = builder.toString()
    println(result)
}

//多次调用StringBuilder代码，考虑使用with方法使得代码更加精简
fun eatfruits_1() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
    //with第一个参数传入StringBuilder对象，接下来Lambda的上下文都是该StringBuilder对象。
    val result = with(StringBuilder()) {
        append("Starting eat fruit\n")
        for (fruit in list) {
            append(fruit).append("\n")
        }
        append("Ate all fruits.\n")
        //Lambda的最后一行作为with函数的返回值返回，最终将结果打印出来
        toString()
    }
    println(result)
}

run
标准函数Run函数与with非常类似，run函数不能直接调用，一定要调用某个对象的run函数，其次run函数只接受一个Lambda参数，并且会在Lambda表达式中提供调用对象的上下文，并将最后一行代码作为返回值返回。实例代码如下：

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

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

apply
最后我们要介绍的是apply函数。apply函数与run函数极其类似，都是在某对象上调用，然后接受一个Lambda参数，也会提供响应上下文。不同的是apply函数无法指定返回值，而是会自动返回调用对象本身。实例代码如下：

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

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

定义静态方法

1、单例类代替

//单例类
object Util {
    //doAction虽然不是静态方法，但仍然可以使用Util.doAction来实现
    fun doAcction() {
        println("do action")
    }
}

2、使用单例类会将整个类中的所有方法都变成类似于静态方法的调用方法，若果只希望其中的一个是静态方法，就需要用到companion object关键字了。

package com.company
//1.将Util从单例类改成普通类
class Util {
    fun doAction1() {
        println("do action1")
    }
    //2.companion object里面的方法可以直接调用Util.doAction2()调用，前者必须要先创建Util类的实例才能调用
    companion object {
        fun doAction2() {
            println("do action2")
        }
    }
}

本质上讲doAction2不是静态方法，componion object会在Util内部创建一个伴生类，doAction2其实就是伴生类的实例方法。Kotlin保证了Util类只会有一个伴生类对象，因此该调用实质上是Util类中伴生对象的doAction2方法。

3、真正的静态方法–>两种方案：注解和顶层方法。

注解是在单例类或者ompanion object中的方法加上@JvmStatic注解。

class Util2 {
    fun doAction1() {
        println("do action1")
    }
    companion object {
        @JvmStatic
        fun doAction2() {
            println("do action2")
        }
    }
}

顶层方法是那些没有定义在任何类中的方法

package com.example.myapplication
 
fun doSomething(){
    println("do something")
}

fun main() {
    doSomeSting()
}