kotlin 標準函數和靜態方法 with、run、apply

一.標準函數

1.with函數

with函數接受兩個參數，第一個是任意類型的對象，第二個是lambda表達式。

作用：連續調用同一對象的多個方法。返回值是最後一個值

格式如下：

val result = with(obj){
    // 這裏是obj的上下文
    "value"    // with函數的返回值
}

舉個例子：

//        val list = listOf("a", "b", "c")
//        val builder = StringBuffer()
//        builder.append("start\n")
//        for (item in list) {
//            builder.append(item).append("\n")
//        }
//        builder.append("end")
//        val result = builder.toString()
//        Log.v("TAG", result)

        //相當於上面的代碼
        val list = listOf("a", "b", "c")
        val result = with(StringBuffer()){
            append("start\n")
            for (item in list) {
                append(item).append("\n")
            }
            append("end")
            toString()
        }
        Log.v("TAG", result)

2.run函數

類似with，需要用對象自己調用run函數，只有一個參數並且是lambda表達式。

作用：連續調用同一對象的多個方法。返回值是最後一個值

//        val list = listOf("a", "b", "c")
//        val builder = StringBuffer()
//        builder.append("start\n")
//        for (item in list) {
//            builder.append(item).append("\n")
//        }
//        builder.append("end")
//        val result = builder.toString()
//        Log.v("TAG", result)

        //相當於上面的代碼
        val list = listOf("a", "b", "c")
        val result = StringBuffer().run{
            append("start\n")
            for (item in list) {
                append(item).append("\n")
            }
            append("end")
            toString()
        }
        Log.v("TAG", result)

3.apply函數

類似run函數，不過返回值是自身

作用：連續調用同一對象的多個方法。返回值自身
 

//        val list = listOf("a", "b", "c")
//        val builder = StringBuffer()
//        builder.append("start\n")
//        for (item in list) {
//            builder.append(item).append("\n")
//        }
//        builder.append("end")
//        val result = builder.toString()
//        Log.v("TAG", result)

        //相當於上面的代碼
        val list = listOf("a", "b", "c")
        val result = StringBuffer().apply{
            append("start\n")
            for (item in list) {
                append(item).append("\n")
            }
            append("end")
        }
        Log.v("TAG", result.toString())

二.靜態方法

java中只需要在方法前添加static即可

kotlin中有四種方式：object的單例類模式、companion單例類的可以局部寫靜態方法模式、JvmStatic註解模式、頂層函數模式。

1.object的單例類模式

object Util {
    fun doAction(){
        Log.v("TAG","doAction")
    }
}

//kotlin中調用
Util.doAction()

//java中調用 INSTANCE是Util的單例類
Util.INSTANCE.doAction();

2.companion的局部單例類模式

class Util{
    
    //此處是單例類可以調用的地方
    companion object {

        fun doAction(){
            Log.v("TAG","doAction")
        }

    }
    
    //此處是普通方法
    fun doAction2(){
        Log.v("TAG","doAction")
    }

}

//kotlin調用
Util.doAction()

//java調用，Companion是單例類
Util.Companion.doAction();

3.JvmStatic註釋

JvmStatic註釋成爲真正單例類

注意：JvmStatic只能註釋在單例類或companion object中的方法上

class Util{

    //此處是單例類可以調用的地方
    companion object {

        @JvmStatic
        fun doAction(){
            Log.v("TAG","doAction")
        }

    }

    //此處是普通方法
    fun doAction2(){
        Log.v("TAG","doAction")
    }

}

//kotlin中的調用
Util.doAction()

//java中的調用，成爲了真正的單例類
Util.doAction();

4.頂層函數模式

定義：頂層函數是指那些沒有定義在任何類中的函數

過程：kotlin會將所有頂層函數編譯成靜態方法

特點：頂層函數可以在任何位置被直接調用，寫在任何類的外層即可

//在類的外部
fun doAction(){

}
class Util {
    
}

//kotlin調用方式
doAction()

//java調用方式,真正的靜態方法
UtilKt.doAction();