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
4000
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 }