Kotlin 中let with run apply also 详解

说关键字不对，因为只是预先的定义好的方法，而不是一个关键字，但是我理解的时候是当作一个既定的以存在的理解的（虽然不是关键字

但在kotlin中也是一些可以直接使用的方法），所以就不通篇改了

1）let相关 

下面这个抽象类，使用了一个泛型 T，并且分别使用声明了let函数和 定义了一个抽象函数bb

仔细观察。如果我们想对Info 做一些处理，可以分别用两种方式，一种是覆盖 bb 抽象方法，之后在bb 方法中写业务逻辑。

另一种方式使用let关键字和lambda表达式。这个时候泛型R 就指代了 一个以T 为参数的代码段。而这个代码段并不需要提前写好，可以在调用的时候

再去写，如方法cc中一样。 

可以说let关键字更灵活一些。实际的场景举例，如果我们想要复用某段代码，如果直接使用抽象方法，对同一个数据的不同处理就要声明不同的接口，

但使用let表达式则不需要在基类声明抽象方法。

abstract class Test  {
    inline fun T.let(block:(T)->R):R=block(this)
    abstract fun bb(t:T);
}

class Test2() : Test() {
    var info:Info=Info();
    override fun bb( info:Info){
        Log.e("bb",info.name);
    }
    fun cc(){
        info.let { 
            Log.e("aa",info.name)
            return;
        }
    }
}
data class Info(var name:String="zhangsan");

2）with相关

with的逻辑比较简单，可以说是函数的一个简写。看下面的代码, 如果要对Info 进行操作，可以定义方法，也可以直接使用with关键字。

如果需要复用的代码，可以直接定义方法，如果不需要的直接 使用with关键字

abstract class Test  {
    var t:T?=null;
    
    inline fun  with(receiver: T, block: T.() -> R): R = receiver.block()
}

class Test2 : Test() {
    fun cc(){
        with(t,{
            t?.name;
        });
    }
    fun bb(){
        t?.name;
    }
}
data class Info(var name:String="zhangsan");

3)run 相关

run 和with 类似，是更简洁的书写方式

abstract class Test  {
    var t:T?=null;
    inline fun  T.run(block: T.() -> R): R = block()
    inline fun  with(receiver: T, block: T.() -> R): R = receiver.block()

}

class Test2 : Test() {
    fun cc(){
        with(t,{
            t?.name;
        });
        t.run {
            t?.name;
        }
    }
    fun bb(){
        t?.name;
    }
}
data class Info(var name:String="zhangsan");

4)apply相关

与let类似，但会将自身返回。与java中连续调用同一类中方法使用场景一致。

abstract class Test {
    var t: T? = null;
    inline fun Info.apply(block: Info.()->Unit): Info {
        block();
        return this;
    }
}
class Test2() : Test() {
    fun cc(){
        t?.apply { 
          this.name;
        }?.apply { 
            this.name;
        }
    }
}

5）also相关

also的用法与apply相同，只是写法不同，apply更简洁，如果不需要进行空值判断的情况使用apply更简单

abstract class Test {
    var t: T? = null;
    inline fun Info.apply(block: Info.()->Unit): Info {
        block();
        return this;
    }
    public inline fun  T.also(block: (T) -> Unit): T { block(this); return this }

}
class Test2() : Test() {
    fun cc(){
        t?.apply {
          this.name;
        }?.apply { 
            this.name;
        }
        t.also { 
            t?.name
        }.also {
            t?.name
        }.also {
            t?.name 
        }
    }
}
data class Info(var name:String="zhangsan");

总结，实际上这几个关键字都是kotlin泛型的应用，我们可以定义一个cc 函数如下。

abstract class Test {
    var t: T? = null;
     inline fun  T.cc(block: (T) -> Unit): T { block(this); return this }

}
class Test2() : Test() {
    fun cc(){
            t.cc { 
                
            }.cc { 
                
            }.cc { 
                
            }
    }
}
data class Info(var name:String="zhangsan");