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

}