网页链接：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”。
}