Kotlin学习（二）

一、标准函数和静态方法

1、标准函数 with、run 和 apply

Kotlin 的标准函数指的是 Standard.kt 文件中定义的函数，任何 Kotlin 代码都可以自由的调用所有标准函数，let标准函数已经学过了，它的主要作用是配合.?来进行判空操作。

① with函数

with函数接收两个参数，第一个参数可以是一个任意类型的对象，第二个参数是一个Lambda表达式。
with函数会在Lambda表达式中提供一个参数对象的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。
示例：

val result = with(obj){
	//这里是obj的上下文
	"value" //with的返回函数
}

这个函数可以在连续调用同一个对象的多个方法时让代码变得更加精简。

举个例子，比如有一个水果列表，要吃掉所有水果，并打印结果：

val list = listOf("apple","banana","orange")
val builder = StringBuilder()
builder.append("开始吃。\n")
for(f in list){
	builder.append(f).append("\n")
}
builder.append("吃完了")
val result = builder.toString()
println(result);

这段代码用多次调用了builder对象的方法，这时候我们就可以考虑使用with函数来让代码更加简洁：

val list = listOf("apple","banana","orange")
val result = with(StringBuilder()){
	append("开始吃。\n")
	for(f in list){
		append(f).append("\n")
	}
	append("吃完了")
	toString()
}
println(result);

分析一下这段代码，首先给with函数的第一个参数传入一个StringBuilder对象，那么接下来整个Lambda表达式的上下文就是它。这样以来我们就可以直接调用append()和toString()方法。Lambda表达式会将最后一行代码作为with函数的返回值返回，最终打印结果。

② run函数

run函数的用法和使用场景与with函数类似，只是稍微做了语法改动。
首先run函数通常不会直接调用，而是在某个对象的基础上调用；其次run函数只几首一个Lambda参数，并且会在Lambda表达式中提供调用对象的上下文。
其他和with函数是一样的，包括Lambda表达式的最后一行作为函数返回。
示例：

val resault = obj.run{
	//这里是obj的上下文
	"value" //run的返回函数
}

下面用run方法修改一下吃水果的代码：

val list = listOf("apple","banana","orange")
val result = StringBuilder().run{
	append("开始吃。\n")
	for(f in list){
		append(f).append("\n")
	}
	append("吃完了")
	toString()
}
println(result);

③ apply函数

apply函数和run函数类似，都要在某个对象上调用，并且只接收一个Lambda参数，也会在Lambda 表达式中提供调用对象的上下文，但apply函数无法指定返回值，而是会自动返回调用对象本身。
示例：

var result = obj.apply{
	//这里是obj的上下文
}
//result == obj

再用apply函数来修改一下吃水果的代码：

val list = listOf("apple","banana","orange")
val result = StringBuilder().apply{
	append("开始吃。\n")
	for(f in list){
		append(f).append("\n")
	}
	append("吃完了")
	toString()
}
println(result.toString);

2、定义静态方法

静态方法在某些编程语言中又叫类方法，指的是那种不需要创建实例就能调用的方法，所有主流编程语言都会支持静态方法这个特性。

但在Kotlin中却极度弱化了静态方法这个概念，想在Kotlin里面定义一个静态方法反倒是不容易，因为Kotlin提供了比静态方法更好用的语法特性----单例类。
像工具类这种功能，就非常推荐使用单例类。

不过在单例类中所有的方法全部都变成了类似静态方法的调用方式，而我们只是希望让类中的某个方法变成静态方法的调用方式，这个时候就是可以使用 companion object 了。
示例：

class Util{
	fun doAction1(){
		print("do Action1")
	}
	companion object {
		fun doAction2(){
			print("do Action2")
		}
	}
}

这里首先我们写了一个普通类，然后在类中直接定义了一个doAction1()方法，又在companion object中定义了一个doAction2()方法。现在两个方法就有了本质上的区别，doAction1()需要船舰Util实例后才能使用，而doAction2()可以直接使用Util.doAction2()调用。

不过doAction2()也不是静态方法，companion object这个关键字实际上会在Util类内部创建一个伴生类，而doAction2()方法就是定义在这个伴生类中的实例方法。只是Kotlin会保证Util中始终只存在一个伴生类对象，因此调用Util.doAction2()实际上就是调用了Util类中伴生对象的doAction2()方法。

由此可以看出，Kotlin中确实没有直接定义静态方法的关键字，但是提供了一些语法特性来支持类似静态方法的调用写法，这些语法特性基本上可以满足我们平时的开发需求了。

如果你确实需要定义真正的静态方法，Kotin仍然提供了两种实现方式：注解和顶层方式。

①注解

前面的单例类和companion object只是在语法的形式上模仿了静态方法的调用方式，实际上不是真正的静态方法。

如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法。
例如：

class Util{
	fun doAction1(){
		print("do Action1")
	}
	companion object {
		@JvmStatic
		fun doAction2(){
			print("do Action2")
		}
	}
}

注意：@JvmStatic注解只能加在单例类或者companion object中的方法上。

此时doAction2()已经成为真正的静态方法。

② 顶层方法

顶层方法指的是哪些没有定义在任何类中的方法，比如main方法。Kotlin会将所有的顶层方法全部编译成静态方法，因此你定义了一个顶层方法，那么它一定是静态方法。
想要定义一个顶层方法，首先要创建一个Kotlin文件，创建类型需要时File。
假设创建的文件名为Do.kt

fun doSome(){
	println("。。。")
}

任何顶层方法都可以在任何位置调用，调用该方法直接写方法名即可，不用管包名路径，也不用创建实例。

但如果在java代码中调用，因为java中没有顶层方法这个概念，所以无法直接使用方法名调用该方法。
假如方法所在的文件名为Helper.kt，Kotlin编译器会自动创建一个角坐DoKt的Java类，doSome()方法就是作为静态方法的形式定义在DoKt类中的，调用的话使用DoKt.doSome()调用即可。

二、一个语法糖

在Java中有一个Java Bean的概念，它是一个非常简单的Java类，会根据类中的字段自动生成相应的Getter和Setter方法，在Kotlin中调用这种语法结构的Java方法中，可以使用一种更简便的方法，例如：

val book = Book()
book.pages = 500
val bookPages = book.pages

这里其实调用了Book类getPages()方法和setPages方法，在Kotlin中这样写会在背后自动转换成调用getPages()方法和setPages方法。