我的书签
添加书签
移除书签基本语法
这是一组基本语法元素及示例。在每段的末尾都有一个指向相关主题详述的链接。
也可以通过 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. /* 包含嵌套的注释 *⁠/
3. 并且在这里结束。 */
参见编写 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` 在 `&&` 右边自动转换成 `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. }
