Kotlin 标准函数和静态方法示例详解

2022-11-13 19:11:23 示例静态详解

标准函数

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 标准函数静态方法的资料请关注其它相关文章！

相关文章