Kotlin 標準函數和靜態方法示例詳解

Posted on by

標準函數

with

with 的作用是可以在連續調用同一對象的多個方法時讓代碼變得更加精簡

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

看個例子，例如有一個水果列表，現在我們想吃完所有水果，並將結果打印出來

val list = listOf("Apple","Banana","Orange")
val builder = StringBuilder()
builder.append("Start eating fruits\n")
for(fruit in list){
	builder.append(fruit).append("\n")
}
builder.append("Ate all fruits.\n")
val result = builder.toString()
print(result)

Start eating fruitsApple
Banana
Orange
Ate all fruits.

我們可以使用 with 讓代碼更簡單

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

我們給 with 函數第一個參數傳入 StringBuilder 對象，那麼接下來整個 Lambda 表達式的上下文就是這個 StringBuilder。Lambda 表達式最後一行代碼會作為 with 函數的返回值返回

run

首先 run 函數是不能直接調用的，而是一定要調用某個對象的 run 函數才行；其次 run 函數隻接收一個 Lambda 函數，並且會在 Lambda 表達式中提供調用對象的上下文

val result = obj.run{
	//這裡是obj的上下文
	"value"//run函數的返回值
}

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

Apply

apply 函數和 run 函數極其類似，隻不過無法指定返回值，而是會自動返回調用對象本身

val result = obj.apply{
	//這裡是obj的上下文
}
//result == obj

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

我們可以使用 apply 對啟動 Activity 的代碼進行優化，傳遞的參數越多，這種寫法越有優勢

val intent = Intent(this,SecondActivity::class.java).apply { 
	putExtra("param1","data1")
	putExtra("param2","data2")
}
startActivity(intent)

定義靜態方法

在 Java 中定義一個靜態方法非常簡單，隻需要在方法前聲明 static 關鍵字即可

public class Util{
	public static void doAction(){
		System.out.println("do action");
	}
}

調用的時候

Util.doActin();

靜態方法非常適合編寫一些工具類的功能，因為工具類通常沒有創建實例的必要。而 Kotlin 中推薦使用單例類的方法來實現，例如上述 Util 工具類

object Util {
    fun doAction(){
        println("do action")
    }
}

調用的時候

Util.doAction()

不過使用單例類的寫法會將整個類的所有方法全部變成類似於靜態方法的調用方式，而如果我們隻想讓類中某個方法變成靜態方法的調用方式：

class Util {
    fun doAction1(){
        println("do action1")
    }
    companion object{
        fun doAction2(){
            println("do action2")
        }
    } 
}

我們將 Util 變成一個普通類，doAction1() 方法一定要創建 Util 類的實例才能調用，而 doAction2() 可以使用 Util.doAction2() 的方式調用。doAction2() 方法其實也不是靜態方法，companion object 關鍵字實際上會在 Util 類內創建一個伴生類，而 doAction2() 方法就是定義在這個伴生類裡面的實例方法，隻是 Kotlin 會保證 Util 類始終隻會存在一個伴生類對象，因此調用 Util.doAction2() 方法實際上就是調用瞭 Util 類中伴生對象的 Util.doAction2() 方法

由此可見 Kotlin 確實沒有直接定義靜態方法的關鍵字，而是提供瞭一些語法特性來支持類似靜態方法調用的寫法，然而如果你確確實實需要定義真正的靜態方法，Kotlin 仍然提供瞭兩張實現方式：註解和頂層方法

註解

如果我們給單例類或 Companion object 中的方法加上 @JvmStatic 註解，那麼 Kotlin 編譯器就會將這些方法編譯成真正的靜態方法：

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

註意@JvmStatic註解隻能加到單例類或 companion object 中方法上。由於 doAction2() 方法已經成為真正的靜態方法，不管在 Kotlin 還是 Java 中都可以使用 Util.doAction2() 的寫法來調用瞭

頂層方法

頂層方法指的是那些沒有定義在任何類中的方法，例如 main() 方法。Kotlin 編譯器會將所有頂層方法全部編譯成靜態方法。所以如果你定義瞭一個頂層方法，那麼它就一定是靜態方法

現在創建一個 Helper.kt 的 File

現在在這個文件裡定義的任何方法都是頂級方法

fun doSomething(){
    println("do something")
}

所有的頂層方法都可以在任何位置被直接調用，不用管包名路徑，也不用創建實例，直接輸入方法名即可：doSomething()。而在 Java 中不同瞭。Kotlin 編譯器會自動創建一個 HelperKt 的 Java 類，所以使用 HelpterKt.doSomething()即可

classJavaTest {
    public void invokeStaticMethod(){
        HelperKt . doSome thing();
    }
}

以上就是Kotlin 標準函數和靜態方法示例詳解的詳細內容，更多關於Kotlin 標準函數靜態方法的資料請關註WalkonNet其它相關文章！

推薦閱讀：