KOTLIN開發語言文檔（官方文檔） -- 入門

網頁鏈接：https://kotlinlang.org/docs/reference/basic-syntax.html

1.   入門

1.1.  基本語法

1.1.1.   定義包

包說明應該在源文件的頂部：

package my.demo
import java.util.*
// …

並不要求包與目錄匹配：源文件可以在文件系統中的任意地方。

查看：包（2.2）

1.1.2.   定義函數

函數帶有Int類型參數，並返回Int類型值：

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

函數體可以是表達式，並可從中推斷出返回值類型：

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

函數可返回無意義的值：

fun pringSum(a: Int, b: Int): Unit {
    print(a + b)
}

Unit 返回值類型可以省略：

public fun printSum(a: Int, b: Int) {
    print(a + b)
}

查看：函數（4.1）

1.1.3.   定義局部變量

一次賦值（只讀）局部變量：

 

val a: Int = 1
val b: = 1    // 推測為Int 類型
val c: Int    // 沒有初始化就要求說明類型
c = 1         // 明確賦值

可變變量：

var x = 5    // 推測為Int類型
x += 1

查看：屬性和域（3.2）

1.1.4.   使用字符串模板

 

fun main(args: Array<String>) {
    if (args.size == 0) return

    print(“First argument: ${args[0]}”)
}

查看：串模板（2.1.5.2）

1.1.5.   使用條件表達式

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

使用if表達式：

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

查看：if表達式（2.3.1）

1.1.6.   使用nullable值檢測空（null）值

當null值可能出現時，引用必須明確標記出可null值。

如果str沒有保存一整數，則返回 null：

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

用函數返回可null值：

 

fun main(args: Array<String>) {
  if (args.size < 2) {
    print("Two integers expected")
    return
  }

  val x = parseInt(args[0])
  val y = parseInt(args[1])

  // 由於x、y是null，所以使用 x * y 將產生錯誤。
  if (x != null && y != null) {
    // 在null檢查后，x 和 y 自動地配置（cast）到非可null
    print(x * y)
  }
}

或

// ...
if (x == null) {
    print("Wrong number format in '${args[0]}'")
    return
}
if (y == null) {
    print("Wrong number format in '${args[1]}'")
    return
}

// 在null檢查后，x 和 y 自動地配置（cast）到非可nul
print(x * y)

查看：Null安全（5.7）

1.1.7.   使用類型檢查和自動類型轉換

is操作符檢查表達式是否類型實例。如果對不可變局部的變量或屬性進行特定類型檢查了，就不需要明確的類型轉換。

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // 在這個分支中，`obj`自動轉換到`String`
    return obj.length
  }

  // 在類型檢查分支之外，`obj`仍然是`Any`類型
  return null
}

或

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

  // 在這個分支上，`obj`自動轉換到`String`
  return obj.length
}

甚至

fun getStringLength(obj: Any): Int? {
  // 在`&&`右手邊條件成立時，`obj`自動轉換到`String`
  if (obj is String && obj.length > 0)
    return obj.length

  return null
}

查看：類（3.1.1）和類型轉換（5.3）

1.1.8.   使用for循環

fun main(args: Array<String>) {
  for (arg in args)
    print(arg)
}

或

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

查看：for循環（2.3.3）

1.1.9.   使用while循環

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

查看：while循環（2.3.4）

1.1.10.   使用when表達式

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

查看：when表達式（2.3.2）

1.1.11.   使用range（范圍）

使用in操作符檢查一個數字是否在一個范圍內：

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

檢查一個數字是否超出范圍：

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

遍歷整個范圍：

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

查看：范圍（5.2）

1.1.12.   使用集合

遍歷一個集合：

for (name in names)
  println(name)

使用in操作符檢查一個集合是否一個對象：

if (text in names) // 調用names.contains(text)
  print("Yes")

使用Lambda表達式過濾和映射集合：

names
    .filter { it.startsWith("A") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { print(it) }

查看：高階函數和Lambda表達式（4.2）

1.2.  習慣用語

這里隨機收集了一些經常在Kotlin中使用的習慣用語。如果你有喜歡用於，也請奉獻出來。申請內容合並。

1.2.1.   創建DTO（POJO / POCO）

data class Customer(val name: String, val email: String)

提供帶有下列功能的Customer類：

——所有屬性的getter (和var的setter)

—— equals()

—— hashCode()

—— toString()

—— copy()

——所有屬性的component1()，component2()，…（查看：數據類（3.6））

1.2.2.   函數參數的默認值

fun foo(a: Int = 0, b: String = “”) {…}

1.2.3.   過濾列表

val positives = list.filter {x -> x > 0}

或是更簡潔寫法：

val positives = list.filter {it > 0}

1.2.4.   字符串插值

println(“Name $name”)

1.2.5.   實例檢查

when (x) {
is Foo -> …
is Bar -> …
else  -> …
}

1.2.6.   遍歷映射表/列表對

for ((k, v) in map) {
    println(“$k -> $v”)
}

k，v可以調用任意事。

1.2.7.   使用范圍

 

for (i in 1 .. 100) { … }

for (x in 2 .. 10) { … }

 

1.2.8.   只讀列表

 

val list = listOf(“a”, “b”, “c”)

 

1.2.9.   只讀映射表

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

 

1.2.10.   訪問映射表

println(map["key"])
map["key"] = value

 

1.2.11.   Lazy property Lazy屬性

val p: String by lazy {

    // 計算串

}

 

1.2.12.   擴展函數

fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()

 

1.2.13.   創建單例模式

object Resource {

    val name = "Name"

}

 

1.2.14.   If非空簡寫

val files = File("Test").listFiles()

println(files?.size)

 

1.2.15.   If非空和else簡寫

val files = File("Test").listFiles()

println(files?.size ?: "empty")

 

1.2.16.   if空，執行語句

val data = ...

val email = data["email"] ?: throw IllegalStateException("Email is missing!")

 

1.2.17.   if非空，執行語句

val data = ...

data?.let {

    ... // 如果非null，執行這段代碼塊

}

 

1.2.18.   when語句返回值

fun transform(color: String): Int {

    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }

}

 

1.2.19.   ‘try/catch’表達式

fun test() {

    val result = try {

        count()

    } catch (e: ArithmeticException) {

        throw IllegalStateException(e)

    }
    // 與result一起工作
}

 

1.2.20.   ‘if’表達式

fun foo(param: Int) {

    val result = if (param == 1) {

        "one"

    } else if (param == 2) {

        "two"

    } else {

        "three"

    }
}

 

1.2.21.   返回Unit類型的方法生成器風格用法

fun arrayOfMinusOnes(size: Int): IntArray {
    return IntArray(size).apply { fill(-1) }
}

 

1.2.22.   單一表達式函數

fun theAnswer() = 42

 

這可以與其他習慣用語有效的組合在一起，簡化代碼。如：與when表達式：

fun transform(color: String): Int = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}

 

1.2.23.   在對象實例中（‘with’）調用多方法

class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()

with(myTurtle) { //繪制100pix 正方形
    penDown()

    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

 

1.2.24.   Java7的try與資源

val stream = Files.newInputStream(Paths.get("/some/file.txt"))

stream.buffered().reader().use { reader ->
    println(reader.readText())
}

 

1.3.  編碼約定

這里是一些Kotlin開發語言的目前編碼風格。

1.3.1.   命名風格

如有疑問，默認的是Java編碼約定，如：

——名稱用駝峰式拼寫法（並避免在名稱中用下划線）

——以大寫字母開始

——方法和屬性名稱以小寫字母開始

——用4空格縮進

—— public函數應有文檔化，使其能在Kotlin文檔中顯示

1.3.2.   冒號

在用冒號分隔類型和子類型時，冒號前需要添加一個空格；而在分隔實例與類型時，冒號前就不需要空格：

interface Foo<out T : Any> : Bar {
    fun foo(a: Int): T
}

 

1.3.3.   Lambda表達式

在Lambda表達式中，空格應該用在花括號兩邊，以及將參數與函數體分隔的箭頭兩側。如果可能，Lambda表達式應該在括號外傳遞。

list.filter { it > 10 }.map { element -> element * 2 }

在簡寫且沒有嵌套的Lambda表達式中，推薦用it約定替代顯式的參數申明。而在帶有參數的嵌套Lambda表達式中，應該總是顯式申明參數。

 

1.3.4.   Unit

如果函數返回Unit類型，則返回類型應該省略：

fun foo() { // 這里省略了“: Unit”。

}