kotlin语法入门

August 30, 2022

简单的语法入门，代码摘自文档。
kotlin 语法较多，无法全部顾及，详细参见文档。
kotlin 能编译到 jvm 和 js，不一致的方面将不涉及。

注意

语句结束无需分号
存在两种相等判断：结构相等（通过 equals() 判断）、引用相等（两个引用指向同一个对象）

变量与类型

基本数据类型：Byte Short Int Long Float Double
在允许范围内，变量自动推断为 Int 和 Double。否则，添加 l/L/f/F 后缀
因为对象引用的原因，没有隐式转换，需使用 toByte() toShort() toInt() toChar() 等
较之 java，kotlin 支持无符号整数：UByte UShort UInt ULong。作为字面量时，加上后缀 u/U 即可

kotlin

val constant: Int = 123
var variable = "number$constant"
var nullable: Int? = constant // 不加问号不装箱，加问号则装箱为（可null）对象。

数组通过模板类表达，对于基础类型数组则可以选用不装箱的优化版本 ByteArray, ShortArray, IntArray

kotlin

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}

对于不会出现的值，返回 Nothing 类型（类似于 typescript 的 never 类型）

类型转换

参见：http://kotlin.liying-cn.net/docs/reference_zh/typecasts.html

控制流

没有三元表达式，用 if/else 替代（最后的语句作为返回值）
没有 switch，使用 when 替代（比 java 的 switch 更好地支持模式匹配）
foreach 迭代器使用 in（for (item in collection)）而不是冒号
支持数值范围 for (i in 1..3)（闭区间，与 rust 不同）for (i in 1 until 10)（左闭右开），具体参考此处
支持 try catch，并可以返回值

kotlin

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> {
        print("x is neither 1 nor 2")
    }
}

面向对象编程

实例化对象无需 new 操作符，kotlin 也没有 new 操作符

kotlin

class InitOrderDemo(name: String) {
    val firstProperty = "First property: $name".also(::println)

    init {
        println("First initializer block that prints $name")
    }

    val secondProperty = "Second property: ${name.length}".also(::println)

    init {
        println("Second initializer block that prints ${name.length}")
    }
}

次构造器，此处主构造器中的 val/var 一并声明对象的属性，支持默认值

kotlin

class Person(val name: String) {
    val children: MutableList<Person> = mutableListOf()
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

在继承中，对象、方法和属性默认不可覆盖，否则需要显示声明 open
接口中允许定义属性

kotlin

// abstract
abstract class Polygon {
    abstract fun draw()
}

class Rectangle : Polygon() {
    override fun draw() {
        // 描绘长方形
    }
}
// super
open class Rectangle {
    open fun draw() { /* ... */ }
}

interface Polygon {
    fun draw() { /* ... */ } // 接口的成员默认是 'open' 的
}

class Square() : Rectangle(), Polygon {
    // 编译器要求 draw() 方法必须覆盖:
    override fun draw() {
        super<Rectangle>.draw() // 调用 Rectangle.draw()
        super<Polygon>.draw() // 调用 Polygon.draw()
    }
}

可见度修饰符与 java 一致，但一些方面与之有差异。（具体见文档）
支持 getter/setter

kotlin

var stringRepresentation: String
    get() = this.toString()
    set(value) {
        setDataFromString(value) // 解析字符串内容, 并将解析得到的值赋给对应的其他属性
    }

支持扩展函数，该函数不是对象的成员，而是静态的

kotlin

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // 'this' 指代 list 实例
    this[index1] = this[index2]
    this[index2] = tmp
}

val list = mutableListOf(1, 2, 3)
list.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'list' 的值

泛型

泛型与 java 一样通过类型擦除实现
较之 java，没有使用 extends super 修饰符，而是借鉴 C#，使用 in out 修饰

kotlin

fun copy(from: Array<out Any>, to: Array<Any>) { ... }
fun fill(dest: Array<in String>, value: String) { ... }
fun <T> singletonList(item: T): List<T> { ... }
fun <T> T.basicToString(): String { ... }
fun <T : Comparable<T>> sort(list: List<T>) { ... }

函数式编程

kotlin 函数的类型声明同 typescript，支持默认值。
支持局部函数（即函数嵌套函数），因此支持闭包。

java

fun double(x: Int) = x * 2
// 支持不定参数
fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts 变量的类型为 Array<out T>
        result.add(t)
    return result
}

在 kotlin 中，函数是一等公民

kotlin

// 注意回调函数（是一个 lambda 函数）的类型声明，与 typescript 是相似的
fun <T, R> Collection<T>.fold(
    initial: R,
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}

// 使用
val items = listOf(1, 2, 3, 4, 5)
// Lambda 表达式是大括号括起的那部分代码.
items.fold(0, {
    // 如果 Lambda 表达式有参数, 首先声明这些参数, 后面是 '->' 符
    acc: Int, i: Int ->
    print("acc = $acc, i = $i, ")
    val result = acc + i
    println("result = $result")
    // Lambda 表达式内的最后一个表达式会被看作返回值:
    result
})

// Lambda 表达式的参数类型如果可以推断得到, 那么参数类型的声明可以省略:
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })

// 在高阶函数调用中也可以使用函数引用:
val product = items.fold(1, Int::times)

支持类型别名

kotlin

typealias ClickHandler = (Button, ClickEvent) -> Unit

支持匿名函数，作为函数字面值

kotlin

fun(s: String): Int { return s.toIntOrNull() ?: 0 }

函数引用与 java 一致，但 f.invoke(x)与f(x)是相同的

kotlin

val stringPlus: (String, String) -> String = String::plus
val intPlus: Int.(Int) -> Int = Int::plus

println(stringPlus.invoke("<-", "->"))
println(stringPlus("Hello, ", "world!"))

println(intPlus.invoke(1, 1))
println(intPlus(1, 2))
println(2.intPlus(3)) // 与扩展函数类似的调用方式

还可以使用接口实现函数，与 c++类似

kotlin

class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}
val intFunction: (Int) -> Int = IntTransformer()

此外，函数式接口与 java 的写法不同

kotlin

fun interface IntPredicate {
   fun accept(i: Int): Boolean
}

val isEven = IntPredicate { it % 2 == 0 }

fun main() {
   println("Is 7 even? - ${isEven.accept(7)}")
}

由于 lambda 函数细节较多，更多参见：http://kotlin.liying-cn.net/docs/reference_zh/lambdas.html

运算符重载

kotlin 支持运算符重载，参见：http://kotlin.liying-cn.net/docs/reference_zh/operator-overloading.html

作用域函数

参见：https://kotlin.liying-cn.net/docs/reference_zh/scope-functions.html

作用域函数是标准库提供的函数，类型声明如下：

kotlin

inline fun <T, R> T.let(block: (T) -> R): R
inline fun <T, R> T.run(block: T.() -> R): R
inline fun <R> run(block: () -> R): R
inline fun <T, R> with(receiver: T, block: T.() -> R): R
inline fun <T> T.apply(block: T.() -> Unit): T
inline fun <T> T.also(block: (T) -> Unit): T

语法糖

安全调用操作符 `?.`

kotlin

val a = "Kotlin"
val b: String? = null
println(a?.length) // 安全调用操作符在这里是不必要的
println(b?.length) // -> null

Elvis 操作符 `?:`

若左侧为 null 则返回右侧的值

kotlin

val l = b?.length ?: -1
// 相当于
val l: Int = if (b != null) b.length else -1

非 null 判定操作符 `!!`

如果需要可能抛出的 NullPointerException 可以使用

kotlin

val l = b!!.length

安全的类型转换 `as?`

转换失败时返回 null

kotlin

val aInt: Int? = a as? Int

解构声明

kotlin

val (name, age) = person
// 相当于
val name = person.component1()
val age = person.component2()
// 其中，componentN() 函数需要标记为 operator（即 operator fun componentN）

// 用下划线代替未使用的变量
val (_, status) = getResult()

异步与协程

kotlin 的协程采用的不是 async/await 模型

参见：http://kotlin.liying-cn.net/docs/reference_zh/coroutines/coroutines-guide.html

←Back to home

This work is licensed under CC BY-NC-SA 4.0