[关闭]
@cxm-2016 2016-11-21T10:30:58.000000Z 字数 2612 阅读 2253

Kotlin(一)——基本语法

Kotlin

版本:2
翻译:李颖

转载自:Kotlin Reference



定义包

包的定义应该在源代码文件的最上方:

  1. package my.demo
  2. import java.util.*
  3. // ...

源代码所在的目录结构不必与包结构保持一致: 源代码文件可以放置在文件系统的任意位置.

定义函数

以下函数接受两个 Int 类型参数, 并返回 Int 类型结果:

  1. fun sum(a: Int, b: Int): Int {
  2. return a + b
  3. }

以下函数使用表达式语句作为函数体, 返回类型由自动推断决定:

  1. fun sum(a: Int, b: Int) = a + b

以下函数不返回有意义的结果:

  1. fun printSum(a: Int, b: Int): Unit {
  2. print(a + b)
  3. }

返回值为 Unit 类型时, 可以省略:

  1. fun printSum(a: Int, b: Int) {
  2. print(a + b)
  3. }

定义局部变量

只读的局部变量:

  1. val a: Int = 1
  2. val b = 1 // 变量类型自动推断为 `Int` 类型
  3. val c: Int // 没有初始化语句时, 必须明确指定类型
  4. c = 1 // 明确赋值

可读写的变量:

  1. var x = 5 // 变量类型自动推断为 `Int` 类型
  2. x += 1

注释

与 Java 和 JavaScript 一样, Kotlin 支持行末注释, 也支持块注释.

  1. // 这是一条行末注释
  2. /* 这是一条块注释
  3. 可以包含多行内容. */

与 Java 不同, Kotlin 中的块注释允许嵌套.

使用字符串模板

  1. fun main(args: Array<String>) {
  2. if (args.size == 0) return
  3. print("First argument: ${args[0]}")
  4. }

使用条件表达式

  1. fun max(a: Int, b: Int): Int {
  2. if (a > b)
  3. return a
  4. else
  5. return b
  6. }

以表达式的形式使用 if:

  1. fun max(a: Int, b: Int) = if (a > b) a else b

NULL检查机制

当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null.

当 str 中的字符串内容不是一个整数时, 返回 null:

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

以下示例演示如何使用一个返回值可为 null 的函数:

  1. fun main(args: Array<String>) {
  2. if (args.size < 2) {
  3. print("Two integers expected")
  4. return
  5. }
  6. val x = parseInt(args[0])
  7. val y = parseInt(args[1])
  8. // 直接使用 `x * y` 会导致错误, 因为它们可能为 null.
  9. if (x != null && y != null) {
  10. // 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
  11. print(x * y)
  12. }
  13. }

或者

  1. // ...
  2. if (x == null) {
  3. print("Wrong number format in '${args[0]}'")
  4. return
  5. }
  6. if (y == null) {
  7. print("Wrong number format in '${args[1]}'")
  8. return
  9. }
  10. // 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
  11. print(x * y)

使用类型检查和自动类型转换

is 运算符可以检查一个表达式的值是不是某个类型的实例. 如果对一个不可变的局部变量或属性进行过类型检查, 那么之后的代码就不必再对它进行显式地类型转换, 而可以直接将它当作需要的类型来使用:

  1. fun getStringLength(obj: Any): Int? {
  2. if (obj is String) {
  3. // 在这个分支中, `obj` 的类型会被自动转换为 `String`
  4. return obj.length
  5. }
  6. // 在类型检查所影响的分支之外, `obj` 的类型仍然是 `Any`
  7. return null
  8. }

或者

  1. fun getStringLength(obj: Any): Int? {
  2. if (obj !is String)
  3. return null
  4. // 在这个分支中, `obj` 的类型会被自动转换为 `String`
  5. return obj.length
  6. }

甚至还可以

  1. fun getStringLength(obj: Any): Int? {
  2. // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
  3. if (obj is String && obj.length > 0)
  4. return obj.length
  5. return null
  6. }

使用 for 循环

  1. fun main(args: Array<String>) {
  2. for (arg in args)
  3. print(arg)
  4. }

或者

  1. for (i in args.indices)
  2. print(args[i])

使用 while 循环

  1. fun main(args: Array<String>) {
  2. var i = 0
  3. while (i < args.size)
  4. print(args[i++])
  5. }

使用 when 表达式

  1. fun cases(obj: Any) {
  2. when (obj) {
  3. 1 -> print("One")
  4. "Hello" -> print("Greeting")
  5. is Long -> print("Long")
  6. !is String -> print("Not a string")
  7. else -> print("Unknown")
  8. }
  9. }

使用范围值

使用 in 运算符检查一个数值是否在某个范围之内:

  1. if (x in 1..y-1)
  2. print("OK")

检查一个数值是否在某个范围之外:

  1. if (x !in 0..array.lastIndex)
  2. print("Out")

在一个值范围内进行遍历迭代:

  1. for (x in 1..5)
  2. print(x)

使用集合(Collection)

在一个集合上进行遍历迭代:

  1. for (name in names)
  2. println(name)

使用 in 运算符检查一个集合是否包含某个对象:

  1. if (text in names) // 将会调用 names.contains(text) 方法
  2. print("Yes")

使用 Lambda 表达式, 对集合元素进行过滤和变换:

  1. names
  2. .filter { it.startsWith("A") }
  3. .sortedBy { it }
  4. .map { it.toUpperCase() }
  5. .forEach { print(it) }
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注