Kotlin開發語言文檔，第一章：入門
1. 入門
1.1. 基本語法
1.1.1. 定義包
包說明應該在源文件的頂部：
1 package my.demo 2 import java.util.* 3 // …
並不要求包與目錄匹配：源文件可以在文件系統中的任意地方。
查看：包（2.2）
1.1.2. 定義函數
函數帶有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 pringSum(a: Int, b: Int): Unit { 2 print(a + b) 3 }
Unit 返回值類型可以省略：
1 public fun printSum(a: Int, b: Int) { 2 print(a + b) 3 }
查看：函數（4.1）
1.1.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
查看：屬性和域（3.2）
1.1.4. 使用字元串模板
1 fun main(args: Array<String>) { 2 if (args.size == 0) return 3 4 print(“First argument: ${args[0]}”) 5 }
查看：串模板（2.1.5.2）
1.1.5. 使用條件表達式
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
查看：if表達式（2.3.1）
1.1.6. 使用nullable值檢測空（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 7 val x = parseInt(args[0]) 8 val y = parseInt(args[1]) 9 10 // 由於x、y是null，所以使用 x * y 將產生錯誤。 11 if (x != null && y != null) { 12 // 在null檢查後，x 和 y 自動地配置（cast）到非可null 13 print(x * y) 14 } 15 }
或
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 11 // 在null檢查後，x 和 y 自動地配置（cast）到非可nul 12 print(x * y)
查看：Null安全（5.7）
1.1.7. 使用類型檢查和自動類型轉換
is操作符檢查表達式是否類型實例。如果對不可變局部的變數或屬性進行特定類型檢查了，就不需要明確的類型轉換。
1 fun getStringLength(obj: Any): Int? { 2 if (obj is String) { 3 // 在這個分支中，`obj`自動轉換到`String` 4 return obj.length 5 } 6 7 // 在類型檢查分支之外，`obj`仍然是`Any`類型 8 return null 9 }
或
1 fun getStringLength(obj: Any): Int? { 2 if (obj !is String) 3 return null 4 5 // 在這個分支上，`obj`自動轉換到`String` 6 return obj.length 7 }
甚至
1 fun getStringLength(obj: Any): Int? { 2 // 在`&&`右手邊條件成立時，`obj`自動轉換到`String` 3 if (obj is String && obj.length > 0) 4 return obj.length 5 6 return null 7 }
查看：類（3.1.1）和類型轉換（5.3）
1.1.8. 使用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])
查看：for迴圈（2.3.3）
1.1.9. 使用while迴圈
1 fun main(args: Array<String>) { 2 var i = 0 3 while (i < args.size) 4 print(args[i++]) 5 }
查看：while迴圈（2.3.4）
1.1.10. 使用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 }
查看：when表達式（2.3.2）
1.1.11. 使用range（範圍）
使用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)
查看：範圍（5.2）
1.1.12. 使用集合
遍歷一個集合：
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) }
查看：高階函數和Lambda表達式（4.2）
1.2. 習慣用語
這裡隨機收集了一些經常在Kotlin中使用的習慣用語。如果你有喜歡用於，也請奉獻出來。申請內容合併。
1.2.1. 創建DTO（POJO / POCO）
1 data class Customer(val name: String, val email: String)
提供帶有下列功能的Customer類：
——所有屬性的getter (和var的setter)
—— equals()
—— hashCode()
—— toString()
—— copy()
——所有屬性的component1()，component2()，…（查看：數據類（3.6））
1.2.2. 函數參數的預設值
1 fun foo(a: Int = 0, b: String = “”) {…}
1.2.3. 過濾列表
1 val positives = list.filter {x -> x > 0}
或是更簡潔寫法：
1 val positives = list.filter {it > 0}
1.2.4. 字元串插值
1 println(“Name $name”)
1.2.5. 實例檢查
1 when (x) { 2 is Foo -> … 3 is Bar -> … 4 else -> … 5 }
1.2.6. 遍歷映射表/列表對
1 for ((k, v) in map) { 2 println(“$k -> $v”) 3 }
k，v可以調用任意事。
1.2.7. 使用範圍
1 for (i in 1 .. 100) { … } 2 3 for (x in 2 .. 10) { … }
1.2.8. 只讀列表
1 val list = listOf(“a”, “b”, “c”)
1.2.9. 只讀映射表
1 val map = mapOf("a" to 1, "b" to 2, "c" to 3)
1.2.10. 訪問映射表
1 println(map["key"]) 2 map["key"] = value
1.2.11. Lazy property Lazy屬性
1 val p: String by lazy { 2 3 // 計算串 4 5 }
1.2.12. 擴展函數
1 fun String.spaceToCamelCase() { ... } 2 3 "Convert this to camelcase".spaceToCamelCase()
1.2.13. 創建單例模式
1 object Resource { 2 3 val name = "Name" 4 5 }
1.2.14. If非空簡寫
1 val files = File("Test").listFiles() 2 3 println(files?.size)
1.2.15. If非空和else簡寫
1 val files = File("Test").listFiles() 2 3 println(files?.size ?: "empty")
1.2.16. if空，執行語句
1 val data = ... 2 3 val email = data["email"] ?: throw IllegalStateException("Email is missing!")
1.2.17. if非空，執行語句
1 val data = ... 2 3 data?.let { 4 5 ... // 如果非null，執行這段代碼塊 6 7 }
1.2.18. when語句返回值
1 fun transform(color: String): Int { 2 3 return when (color) { 4 "Red" -> 0 5 "Green" -> 1 6 "Blue" -> 2 7 else -> throw IllegalArgumentException("Invalid color param value") 8 } 9 10 }
1.2.19. ‘try/catch’表達式
1 fun test() { 2 3 val result = try { 4 5 count() 6 7 } catch (e: ArithmeticException) { 8 9 throw IllegalStateException(e) 10 11 } 12 // 與result一起工作 13 }
1.2.20. ‘if’表達式
1 fun foo(param: Int) { 2 3 val result = if (param == 1) { 4 5 "one" 6 7 } else if (param == 2) { 8 9 "two" 10 11 } else { 12 13 "three" 14 15 } 16 }
1.2.21. 返回Unit類型的方法生成器風格用法
1 fun arrayOfMinusOnes(size: Int): IntArray { 2 return IntArray(size).apply { fill(-1) } 3 }
1.2.22. 單一表達式函數
1 fun theAnswer() = 42
這可以與其他習慣用語有效的組合在一起，簡化代碼。如：與when表達式：
1 fun transform(color: String): Int = when (color) { 2 "Red" -> 0 3 "Green" -> 1 4 "Blue" -> 2 5 else -> throw IllegalArgumentException("Invalid color param value") 6 }
1.2.23. 在對象實例中（‘with’）調用多方法
1 class Turtle { 2 fun penDown() 3 fun penUp() 4 fun turn(degrees: Double) 5 fun forward(pixels: Double) 6 } 7 8 val myTurtle = Turtle() 9 10 with(myTurtle) { //繪製100pix 正方形 11 penDown() 12 13 for(i in 1..4) { 14 forward(100.0) 15 turn(90.0) 16 } 17 penUp() 18 }
1.2.24. Java7的try與資源
1 val stream = Files.newInputStream(Paths.get("/some/file.txt")) 2 3 stream.buffered().reader().use { reader -> 4 println(reader.readText()) 5 }
1.3. 編碼約定
這裡是一些Kotlin開發語言的目前編碼風格。
1.3.1. 命名風格
如有疑問，預設的是Java編碼約定，如：
——名稱用駝峰式拼寫法（並避免在名稱中用下劃線）
——以大寫字母開始
——方法和屬性名稱以小寫字母開始
——用4空格縮進
—— public函數應有文檔化，使其能在Kotlin文檔中顯示
1.3.2. 冒號
在用冒號分隔類型和子類型時，冒號前需要添加一個空格；而在分隔實例與類型時，冒號前就不需要空格：
1 interface Foo<out T : Any> : Bar { 2 fun foo(a: Int): T 3 }
1.3.3. Lambda表達式
在Lambda表達式中，空格應該用在花括弧兩邊，以及將參數與函數體分隔的箭頭兩側。如果可能，Lambda表達式應該在括弧外傳遞。
1 list.filter { it > 10 }.map { element -> element * 2 }
在簡寫且沒有嵌套的Lambda表達式中，推薦用it約定替代顯式的參數申明。而在帶有參數的嵌套Lambda表達式中，應該總是顯式申明參數。
1.3.4. Unit
如果函數返回Unit類型，則返回類型應該省略：
1 fun foo() { // 這裡省略了“: Unit”。 2 3 }
