Kotlin学习笔记之基础篇二

1.1 标准函数

标准函数with、run和apply

Kotlin的标准函数指的是Standard.kt文件中定义的函数，任何Kotlin代码都可以自由地调用所有的标准函数。

with函数

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

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

val list = listOf("Apple", "Banana")
val result = with(StringBuilder()) {
    append("start")
    for (fruit in list) append(fruit)
    append("end")
    toString()
}
1
2
3
4
5
6
7

run函数

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

val result = obj.run {
    // 这里是obj的上下文
    "value" // run函数的返回值
}
1
2
3
4

val list = listOf("Apple", "Banana")
val result = StringBuilder().run {
    append("start")
    for (fruit in list) append(fruit)
    append("end")
    toString()
}
1
2
3
4
5
6
7

apply函数

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

val result = obj.apply {
    // 这里是obj的上下文
}
// result == obj
1
2
3
4

val list = listOf("Apple", "Banana")
val result = StringBuilder().apply {
    append("start")
    for (fruit in list) append(fruit)
    append("end")
}
val sb = result.toString()
1
2
3
4
5
6
7

1.2 静态方法

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

定义静态方法通过companion object关键字

class Util {
    fun doAction1() {

    }

    companion object {
        fun doAction2() {

        }
    }
}

fun main() {
    Util.doAction2()
    Util().doAction1()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

实现真正的静态方法

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

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

使用的单例类和companion object都只是在语法的形式上模仿了静态方法的调用方式，实际上它们都不是真正的静态方法。因此如果你在Java代码中以静态方法的形式去调用的话，你会发现这些方法并不存在。而如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法，如下所示

class Util {
    fun doAction1() {

    }


    companion object {
        @JvmStatic
        fun doAction2() {

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

顶层方法

顶层方法指的是那些没有定义在任何类中的方法，比如我们在上一节中编写的main()方法。Kotlin编译器会将所有的顶层方法全部编译成静态方法，因此只要你定义了一
个顶层方法，那么它就一定是静态方法。

想要定义一个顶层方法，首先需要创建一个Kotlin文件。对着任意包名右击 → New → Kotlin
File/Class，在弹出的对话框中输入文件名即可。注意创建类型要选择File

package com.zooka.esportslive.widget

fun doSome(){
    
}
1
2
3
4
5

如果是在Kotlin代码中调用的话，那就很简单了，所有的顶层方法都可以在任何位置被直接调用，不用管包名路径，也不用创建实例，直接键入doSome()即可

1.3 延迟初始化和密封类

延迟初始化使用lateinit关键字

class MainActivity : AppCompatActivity(), View.OnClickListener {
    private lateinit var adapter: MsgAdapter
    override fun onCreate(savedInstanceState: Bundle?)    {
        ...
        if (!::adapter.isInitialized) {
            adapter = MsgAdapter(msgList)
        }
        ...
 }
1
2
3
4
5
6
7
8
9

::adapter.isInitialized可用于判断adapter变量是否已经初始化

使用密封类优化代码通过sealed关键字

密封类及其所有子类只能定义在同一个文件的顶层位置，不能嵌套在其他类中，这是被密封类底层的实现机制所限制的

interface Result
class Success(val msg: String) : Result
class Fail(val error: Error) : Result

fun getResult(result: Result) = when (result) {
    is Success -> result.msg
    is Fail -> result.error.message
    else -> throw IllegalAccessException()
}
1
2
3
4
5
6
7
8
9

sealed class Fruit
class Orange() : Fruit()
class Apple() : Fruit()

fun getFruit(fruit: Fruit) = when (fruit) {
    is Orange -> print("orange")
    is Apple -> print("apple")
}
1
2
3
4
5
6
7
8