持续创造，加速成长！这是我参与「掘金日新方案 10 月更文应战」的第29天，点击查看活动概况

规范函数

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)

【Kotlin】标准函数和静态方法

咱们能够运用 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

【Kotlin】标准函数和静态方法

现在在这个文件里界说的任何办法都是尖端办法

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

一切的顶层办法都能够在任何位置被直接调用，不必管包名路径，也不必创立实例，直接输入办法名即可：doSomething()。而在 Java 中不同了。Kotlin 编译器会自动创立一个 HelperKt 的 Java 类，所以运用 HelpterKt.doSomething()即可

【Kotlin】标准函数和静态方法