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

2022-10-30 14:00:15

標準函數

with

with 的作用是可以在連續呼叫同一物件的多個方法時讓程式碼變得更加精簡

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

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

val list = listOf("Apple","Banana","Orange")
val builder = StringBuilder()
builder.append("Start eating fruitsn")
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 標準函數靜態方法的資料請關注it145.com其它相關文章！