基本语法

    这是一组基本语法元素及示例。在每段的末尾都有一个指向相关主题详述的链接。

    也可以通过 JetBrains 学院上的免费 Kotlin 基础课程学习所有 Kotlin 要领。

    包的定义与导入

    包的声明应处于源文件顶部。

    1. package my.demo
    3. import kotlin.text.
    5. // ……

    目录与包的结构无需匹配：源代码可以在文件系统的任意位置。

    参见包。

    程序入口点

    Kotlin 应用程序的入口点是 main 函数。

    1. fun main() {
    2.     println("Hello world!")
    3. }

    main 的另一种形式接受可变数量的 String 参数。 

    1. fun main(args: Array<String>) {
    2.     println(args.contentToString())
    3. }

    输出打到标准输出

    print 将其参数打到标准输出。

    1. fun main() {
    2. //sampleStart
    3.     print("Hello ")
    4.     print("world!")
    5. //sampleEnd
    6. }

    println 输出其参数并添加换行符，以便接下来输出的内容出现在下一行。

    1. fun main() {
    2. //sampleStart
    3.     println("Hello world!")
    4.     println(42)
    5. //sampleEnd
    6. }

    函数

    带有两个 Int 参数、返回 Int 的函数。

    1. //sampleStart
    2. fun sum(a: Int, b: Int): Int {
    3.     return a + b
    4. }
    5. //sampleEnd
    7. fun main() {
    8.     print("sum of 3 and 5 is ")
    9.     println(sum(3, 5))
    10. }

    函数体可以是表达式。其返回类型可以推断出来。

    1. //sampleStart
    2. fun sum(a: Int, b: Int) = a + b
    3. //sampleEnd
    5. fun main() {
    6.     println("sum of 19 and 23 is ${sum(19, 23)}")
    7. }

    返回无意义的值的函数。

    1. //sampleStart
    2. fun printSum(a: Int, b: Int): Unit {
    3.     println("sum of $a and $b is ${a + b}")
    4. }
    5. //sampleEnd
    7. fun main() {
    8.     printSum(-1, 8)
    9. }

    Unit 返回类型可以省略。

    1. //sampleStart
    2. fun printSum(a: Int, b: Int) {
    3.     println("sum of $a and $b is ${a + b}")
    4. }
    5. //sampleEnd
    7. fun main() {
    8.     printSum(-1, 8)
    9. }

    参见函数。

    变量

    定义只读局部变量使用关键字 val 定义。只能为其赋值一次。

    1. fun main() {
    2. //sampleStart
    3.     val a: Int = 1  // 立即赋值
    4.     val b = 2   // 自动推断出 Int 类型
    5.     val c: Int  // 如果没有初始值类型不能省略
    6.     c = 3       // 明确赋值
    7. //sampleEnd
    8.     println("a = $a, b = $b, c = $c")
    9. }

    可重新赋值的变量使用 var 关键字。

    1. fun main() {
    2. //sampleStart
    3.     var x = 5 // 自动推断出 Int 类型
    4.     x += 1
    5. //sampleEnd
    6.     println("x = $x")
    7. }

    可以在顶层声明变量。

    1. //sampleStart
    2. val PI = 3.14
    3. var x = 0
    5. fun incrementX() { 
    6.     x += 1 
    7. }
    8. //sampleEnd
    10. fun main() {
    11.     println("x = $x; PI = $PI")
    12.     incrementX()
    13.     println("incrementX()")
    14.     println("x = $x; PI = $PI")
    15. }

    参见属性。

    创建类与实例

    使用 class 关键字定义类。

    1. class Shape

    类的属性可以在其声明或主体中列出。 

    1. class Rectangle(var height: Double, var length: Double) {
    2.     var perimeter = (height + length)  2 
    3. }

    具有类声明中所列参数的默认构造函数会自动可用。 

    1. class Rectangle(var height: Double, var length: Double) {
    2.     var perimeter = (height + length)  2 
    3. }
    4. fun main() {
    5. //sampleStart
    6.     val rectangle = Rectangle(5.0, 2.0)
    7.     println("The perimeter is ${rectangle.perimeter}")
    8. //sampleEnd
    9. }

    类之间继承由冒号（:）声明。默认情况下类都是 final 的；如需让一个类可继承， 请将其标记为 open。

    1. open class Shape
    3. class Rectangle(var height: Double, var length: Double): Shape() {
    4.     var perimeter = (height + length)  2 
    5. }

    参见类以及对象与实例。

    注释

    与大多数现代语言一样，Kotlin 支持单行（或行末）与多行（块）注释。

    1. // 这是一个行注释
    3. / 这是一个多行的
    4.    块注释。 /

    Kotlin 中的块注释可以嵌套。

    1. / 注释从这里开始
    2. / 包含嵌套的注释 &#8288;/
      并且在这里结束。       /

    参见编写 Kotlin 代码文档 查看关于文档注释语法的信息。

    字符串模板

    1. fun main() {
    2. //sampleStart
    3.     var a = 1
    4.     // 模板中的简单名称：
    5.     val s1 = "a is $a" 
    7.     a = 2
    8.     // 模板中的任意表达式：
    9.     val s2 = "${s1.replace("is", "was")}, but now is $a"
    10. //sampleEnd
    11.     println(s2)
    12. }

    参见字符串模板。

    条件表达式

    1. //sampleStart
    2. fun maxOf(a: Int, b: Int): Int {
    3.     if (a > b) {
    4.         return a
    5.     } else {
    6.         return b
    7.     }
    8. }
    9. //sampleEnd
    11. fun main() {
    12.     println("max of 0 and 42 is ${maxOf(0, 42)}")
    13. }

    在 Kotlin 中，if 也可以用作表达式。

    1. //sampleStart
    2. fun maxOf(a: Int, b: Int) = if (a > b) a else b
    3. //sampleEnd
    5. fun main() {
    6.     println("max of 0 and 42 is ${maxOf(0, 42)}")
    7. }

    参见if 表达式。

    for 循环

    1. fun main() {
    2. //sampleStart
    3.     val items = listOf("apple", "banana", "kiwifruit")
    4.     for (item in items) {
    5.         println(item)
    6.     }
    7. //sampleEnd
    8. }

    或者

    1. fun main() {
    2. //sampleStart
    3.     val items = listOf("apple", "banana", "kiwifruit")
    4.     for (index in items.indices) {
    5.         println("item at $index is ${items[index]}")
    6.     }
    7. //sampleEnd
    8. }

    参见 for 循环。

    while 循环

    1. fun main() {
    2. //sampleStart
    3.     val items = listOf("apple", "banana", "kiwifruit")
    4.     var index = 0
    5.     while (index < items.size) {
    6.         println("item at $index is ${items[index]}")
    7.         index++
    8.     }
    9. //sampleEnd
    10. }

    参见 while 循环。

    when 表达式

    1. //sampleStart
    2. fun describe(obj: Any): String =
    3.     when (obj) {
    4.         1          -> "One"
    5.         "Hello"    -> "Greeting"
    6.         is Long    -> "Long"
    7.         !is String -> "Not a string"
    8.         else       -> "Unknown"
    9.     }
    10. //sampleEnd
    12. fun main() {
    13.     println(describe(1))
    14.     println(describe("Hello"))
    15.     println(describe(1000L))
    16.     println(describe(2))
    17.     println(describe("other"))
    18. }

    参见 when 表达式。

    使用区间（range）

    使用 in 操作符来检测某个数字是否在指定区间内。

    1. fun main() {
    2. //sampleStart
    3.     val x = 10
    4.     val y = 9
    5.     if (x in 1..y+1) {
    6.         println("fits in range")
    7.     }
    8. //sampleEnd
    9. }

    检测某个数字是否在指定区间外。

    1. fun main() {
    2. //sampleStart
    3.     val list = listOf("a", "b", "c")
    5.     if (-1 !in 0..list.lastIndex) {
    6.         println("-1 is out of range")
    7.     }
    8.     if (list.size !in list.indices) {
    9.         println("list size is out of valid list indices range, too")
    10.     }
    11. //sampleEnd
    12. }

    区间迭代。

    1. fun main() {
    2. //sampleStart
    3.     for (x in 1..5) {
    4.         print(x)
    5.     }
    6. //sampleEnd
    7. }

    或数列迭代。

    1. fun main() {
    2. //sampleStart
    3.     for (x in 1..10 step 2) {
    4.         print(x)
    5.     }
    6.     println()
    7.     for (x in 9 downTo 0 step 3) {
    8.         print(x)
    9.     }
    10. //sampleEnd
    11. }

    参见区间与数列。

    集合

    对集合进行迭代。

    1. fun main() {
    2.     val items = listOf("apple", "banana", "kiwifruit")
    3. //sampleStart
    4.     for (item in items) {
    5.         println(item)
    6.     }
    7. //sampleEnd
    8. }

    使用 in 操作符来判断集合内是否包含某实例。

    1. fun main() {
    2.     val items = setOf("apple", "banana", "kiwifruit")
    3. //sampleStart
    4.     when {
    5.         "orange" in items -> println("juicy")
    6.         "apple" in items -> println("apple is fine too")
    7.     }
    8. //sampleEnd
    9. }

    使用 lambda 表达式来过滤（filter）与映射（map）集合：

    1. fun main() {
    2. //sampleStart
    3.     val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    4.     fruits
    5.       .filter { it.startsWith("a") }
    6.       .sortedBy { it }
    7.       .map { it.uppercase() }
    8.       .forEach { println(it) }
    9. //sampleEnd
    10. }

    参见集合概述。

    空值与空检测

    当可能用 null 值时，必须将引用显式标记为可空。可空类型名称以问号（?）结尾。

    如果 str 的内容不是数字返回 null：

    1. fun parseInt(str: String): Int? {
    2.     // ……
    3. }

    使用返回可空值的函数：

    1. fun parseInt(str: String): Int? {
    2.     return str.toIntOrNull()
    3. }
    5. //sampleStart
    6. fun printProduct(arg1: String, arg2: String) {
    7.     val x = parseInt(arg1)
    8.     val y = parseInt(arg2)
    10.     // 直接使用 x * y 会导致编译错误，因为它们可能为 null
    11.     if (x != null && y != null) {
    12.         // 在空检测后，x 与 y 会自动转换为非空值（non-nullable）
    13.         println(x  y)
    14.     }
    15.     else {
    16.         println("'$arg1' or '$arg2' is not a number")
    17.     }
    18. }
    19. //sampleEnd
    21. fun main() {
    22.     printProduct("6", "7")
    23.     printProduct("a", "7")
    24.     printProduct("a", "b")
    25. }

    或者

    1. fun parseInt(str: String): Int? {
    2.     return str.toIntOrNull()
    3. }
    5. fun printProduct(arg1: String, arg2: String) {
    6.     val x = parseInt(arg1)
    7.     val y = parseInt(arg2)
    9. //sampleStart
    10.     // ……
    11.     if (x == null) {
    12.         println("Wrong number format in arg1: '$arg1'")
    13.         return
    14.     }
    15.     if (y == null) {
    16.         println("Wrong number format in arg2: '$arg2'")
    17.         return
    18.     }
    20.     // 在空检测后，x 与 y 会自动转换为非空值
    21.     println(x  y)
    22. //sampleEnd
    23. }
    25. fun main() {
    26.     printProduct("6", "7")
    27.     printProduct("a", "7")
    28.     printProduct("99", "b")
    29. }

    参见空安全。

    类型检测与自动类型转换

    is 操作符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换：

    1. //sampleStart
    2. fun getStringLength(obj: Any): Int? {
    3.     if (obj is String) {
    4.         // obj 在该条件分支内自动转换成 String
    5.         return obj.length
    6.     }
    8.     // 在离开类型检测分支后，obj 仍然是 Any 类型
    9.     return null
    10. }
    11. //sampleEnd
    13. fun main() {
    14.     fun printLength(obj: Any) {
    15.         println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    16.     }
    17.     printLength("Incomprehensibilities")
    18.     printLength(1000)
    19.     printLength(listOf(Any()))
    20. }

    或者

    1. //sampleStart
    2. fun getStringLength(obj: Any): Int? {
    3.     if (obj !is String) return null
    5.     // obj 在这一分支自动转换为 String
    6.     return obj.length
    7. }
    8. //sampleEnd
    10. fun main() {
    11.     fun printLength(obj: Any) {
    12.         println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    13.     }
    14.     printLength("Incomprehensibilities")
    15.     printLength(1000)
    16.     printLength(listOf(Any()))
    17. }

    甚至

    1. //sampleStart
    2. fun getStringLength(obj: Any): Int? {
    3.     // obj 在 &amp;&amp; 右边自动转换成 String 类型
    4.     if (obj is String && obj.length > 0) {
    5.         return obj.length
    6.     }
    8.     return null
    9. }
    10. //sampleEnd
    12. fun main() {
    13.     fun printLength(obj: Any) {
    14.         println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    15.     }
    16.     printLength("Incomprehensibilities")
    17.     printLength("")
    18.     printLength(1000)
    19. }

    参见类以及类型转换。