kotlin内置函数：Apply、also、run、let、with的用法

区分kotlin内置函数

apply、also、run、let、with

1、从返回值角度区分

• apply、also返回值是 对象
• run、let返回最后一行代码的 结果值，指定的 return 返回值

2、从内置函数内内使用的对象名称

• apply、run、with使用this
• also、let使用it

使用this可以在内置函数内省略不写直接调用对象的公有成员变量，it必须填上不可省略

---

例子

用Kotlin写了一个Person类进行测试

class Person() {
    
    

    var name: String? = null
    var address: String? = null
    var age: Int = -1

    private fun initDef() {
    
    
        name = "Mr.Li";
        address = "China"
        age = 24
    }

    init {
    
    
        initDef()
    }

    fun setRealName(realName: String) {
    
    
        this.name = realName
    }

    fun setPantName(pantName: String) {
    
    
        this.name = pantName
    }


    override fun toString(): String {
    
    
        return "name : $name || address : $address || age : $age "
    }
}



fun main(args: Array<String>) {
    
    
    val man = Person()
    println("created -> ${
      
      man.toString()}")

    val applyMan = man.apply {
    
    
        this.age = 18
        address = "ShangHai" // this可以省略不写
        setPantName("Lmm")
    }
    println("apply -> ${
      
      applyMan.toString()}")

    val alsoMan = man.also {
    
    
        it.address = "China ShangHai" // it 则不行
        it.setRealName("LiMM")
    }
    println("also -> ${
      
      alsoMan.toString()}")

    val runMan = man.run {
    
    
        age = 30
        setPantName("Kuye")
        this// this 作为最后的返回值
    }
    println("run -> ${
      
      runMan.toString()}")
    println("runMan Type -> ${
      
      runMan.javaClass.typeName}")

    val runManName = man.run {
    
    
        age = 30
        setPantName("Kuye")
        name// name 作为最后的返回值
    }
    println("runManName -> $runManName")
    println("runManName Type -> ${
      
      runManName?.javaClass?.typeName}")

    val runManReturn: String = man.run {
    
    
        age = 30
        setPantName("Kuye")
        name//
        return@run "runManReturn" //直接用Return指定一个返回值  这里可以是表达式、成员函数的返回等等
    }
    println("runManReturn -> $runManReturn")
    println("runManReturn Type -> ${
      
      runManReturn.javaClass.typeName}")

    val letMan = man.let {
    
    
        it.address = "China GUANGXI"
        it.setRealName("LiMI")
        it// it 作为返回值
    }
    println("letMan -> ${
      
      letMan.toString()}")
    println("letMan Type -> ${
      
      letMan.javaClass.typeName}")

    val letManReturn: String = man.run {
    
    
        age = 30
        setRealName("Kuye")
        name//
        return@run "letManReturn" //直接用Return指定一个返回值  这里可以是表达式、成员函数的返回等等
    }
    println("letManReturn -> $letManReturn")
    println("letManReturn Type -> ${
      
      letManReturn.javaClass.typeName}")

    with(man) {
    
    
        // this可以省略不写
        setPantName("LMM")
        this.address = "China SHANGHAI"
        age = 15
    }

    println("with man  -> $man")
}

输出结果：

created -> name : Mr.Li || address : China || age : 24 
apply -> name : Lmm || address : ShangHai || age : 18 
also -> name : LiMM || address : China ShangHai || age : 18 
    
run -> name : Kuye || address : China ShangHai || age : 30 
runMan Type -> infunc.Person
    
runManName -> Kuye
runManName Type -> java.lang.String
    
runManReturn -> runManReturn
runManReturn Type -> java.lang.String
    
letMan -> name : LiMI || address : China GUANGXI || age : 30 
letMan Type -> infunc.Person
    
letManReturn -> letManReturn
letManReturn Type -> java.lang.String
    
with man  -> name : LMM || address : China SHANGHAI || age : 15