Kotlin Basic Syntax

定义 Packages

应该在文件的最顶部定义包名

package my.demo

import java.util.*

//...

文件名与包名并不一定必须一致。

定义函数

定义一个接口两个数字，返回它们和的函数

fun sum(a: Int, b: Int): Int {
  return a + b
}

只有一个表达式作为主体的函数，Kotlin 会自动推断出它的返回类型

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

函数默认会返回无具体意义的值

fun printSum(a: Int, b: Int): Unit {
  println("Sum of $a and $b is ${a + b}")
}

Unit
类型是可以被省略的

fun printSum(a: Int, b: Int) {
  println("Sum of $a and $b is ${a + b}")
}

定义变量

使用 val
定义一个本地只读的只能被赋值一次的变量

val a: Int = 1 // 立即赋值
val b = 2 // `Int` 类型是被推断出来的
val c: Int // 先定义一个 `Int` 类型的变量
c = 3 // 然后再赋值

也可以使用 var
定义一个可以被多次赋值的变量

var x = 5
x += 1

上层变量

val PI = 3.14
var x = 0

fun incrementX() {
  x += 1
}

注释

就如同 Java、JavaScript，Kotlin 同时支持文件行末注释以及块注释：

// 这是一个行末注释

/* 这是一个
  块级注释 */

与 Java 不同点在于，Kotlin 的块注释支持嵌套

使用字符模板

var a = 1
// 模板中和简单名称
val s1 = "a 的值为 $a"

a += 1

// 在模板中的任意格式
val s2 = "${s1.replace("为", "以前为")}，但是现在为 $a"

使用条件表达式

fun maxOf(a: Int, b: Int): Int {
  if (a > b) {
    return a
  } else {
    return b
  }
}

使用 if
表达示

fun maxOf(a: Int, b: Int) = if (a > b) a else b

使用可为 null
的值以及对 null
的检查

对于一个可为 null
的值，必须显示的标记它可能为 null
（ nullable
）

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

在函数中返回可为 null
的值

fun printProduct(arg1: String, arg2: String) {
  val x = parseInt(arg1)
  var y = parseInt(arg2)

  // 使用 `x * y` 的话，会报错误，因为它们有可能为 `null`
  if (x != null & y != null) {
    // 在 `null` 检查完成之后，`x` 与 `y` 会自动的被转为不会为 `null`（`non-nullable`） 的值
    println(x * y)
  }
  else {
    println("'$arg1' 与 '$arg2' 不是都为数字")
  }
}

或者

if (x == null) {
  println("$arg1 的类型错误")
  return
}

if (y == null) {
  println("$arg2 的类型错误")
  return
}
println(x * y)

使用类型检查以及自动类型转换

is
关键字会检测一个值是否是某个类型的，只要完成类型检查，那么被检查的值就可以直接当作该类型去使用。

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // `obj` 已经被自动转换为 `String` 类型了
    return obj.length
  }
  return null
}

或者

fun getStringLength(obj: Any): Int? {
  if (obj !is String) return null
 
  return obj.length
}

也可以

fun getStringLength(obj: Any): Int? {
  if (obj is String && obj.length > 0) {
    return obj.length
  }
  return null
}

使用 for
循环

val items = listOf("apple", "banana", "kiwifrut")
for (item in items) {
  println(item)
}

或者

val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices) {
  println("item at $index is ${items[index]}")
}

使用 while
循环

val items = listOf("apple", "banaba", "kiwifruit")
var index = 0
while (index < items.size) {
  println("item at $index is ${items[index]}")
  index += 1
}

使用 when
表达式

fun describe(obj: Any): String = 
  when (obj) {
    1 -> "One"
    "Hello" -> "Greeting"
    is Long -> "Long"
    !is String -> "Not a string"
    else -> "Unknown"
  }

使用 ranges

检查一个数字是否在一个范围内

val x = 10
val y = 9
if (x in 1..y+1) {
  println("fits in range")
}

检查一个值是否不在一个范围内

val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
  println("-1 不在范围内")
}
if (list.size in !in list.indices) {
  println("list.size 同样的也不在 list.indices 范围内")
}

遍历一个范围

for (x in 1..5) {
  print(x)
}

或者可以指定一个步进值

for (x in 1..10 step 2) {
    print(x)
}
println()
for (x in 9 downTo 0 step 3) {
    print(x)
}

使用集合

遍历一个集合

for (item in items) {
  println(item)
}

使用 in
确定一个集合是否包含某个对象

when {
  "orange" in items -> println("juicy")
  "apple" in items -> println("apple is fine too")
}

在集合上使用 filter
和 map

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits
  .filter { it.startsWith("a") }
  .sortedBy { it }
  .map { it.toUpperCase() }
  .forEach { println(it) }

创建基础类实例

val rectangle = Rectangle(5.0, 2.0) // 不需要 `new` 关键字
val triangle = Triangle(3.0, 4.0, 5.0)