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”。

 }