零、咱们先来看看Kotlin是啥语言。

JetBrains在2016年2月15日Kotlin 1.0发布，这意味着Kotlin经过几年的发展已经稳定而且可以在生产环境使用。再来看一下其他人：

  1. 如何评价 Kotlin 语言
  2. Android开发时你遇到过什么相见恨晚的工具或网站
  3. Kotlin, the Swift of Android
  4. Using Project Kotlin for Android
  5. 使用Kotlin进行Android开发

在网搜索一下就会发现已经有很多人在研究Kotlin并且使用其来开发Android，Android Studio原生就内置了Kotlin的工具和插件，可以方便的使用Kotlin开发Android。个人认为Kotlin没有Java那么多的历史包袱，而且写起来也没有Java那么的繁琐，但是又可以跟Java无缝结合，可以完全使用现在的各种库；相比Scala又简单不少。应该在JVM平台上可以发展得不错。我来学系列记录我自己学习的过程，同时希望可以能跟猿猴们一起探讨开发。下面的内容基本上是照着官方的文档来写，一来自己学习，二来跟大家一起讨论。

一、快速浏览语法

包定义

这个跟Java没有多少区别，在文件的最上面定义包的名字。如果需要引用其他包的内容，紧接着包定义的下面引入：

1
2
3
4
5

package my.demo

import java.util.*

// ...

在Kotlin里面包的名字不一定要跟文件路径一致，一个源代码文件可以定义任意的包名。

定义函数

跟Java不同的是，在Kotlin里面可以定义单独的函数，而Java的函数必须属于某个类。下面是一个求和函数，把两个Int类型的变量相加，返回相加后的结果：

1
2
3

fun sum(a: Int, b: Int): Int {
    return a + b
}

还可以使用表达式的方式和类型推导来把上面的代码写得更加简洁：

1

fun sum(a: Int, b: Int) = a + b

函数可以返回一个代表无值的值Unit，这有点像Java里面的void，但是跟void的意思大不相同。Unit类型表示一个值，但是这个值里面什么都没有：

1
2
3

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

如果函数没有返回值，返回值缺省就是Unit

1
2
3

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

定义变量

不可变的变量，原文是Assign-once (read-only) local variable，其他有一些语言里面称为immutable，个人更愿意使用immutable。也就是说一定赋了值之后，就不可以再被改变。immutable使用关键字val定义

1
2
3
4
5
6
7
8
9

val a: Int = 1
val b = 1   // `Int` type is inferred
val c: Int  // Type required when no initializer is provided
c = 1       // definite assignment

// 上面都没有问题
// 如果再对任意一个变量赋值，编译的时候就会报错
c = 2
// Error:(11, 5) Kotlin: Val cannot be reassigned

跟immutable相对的就是mutable，使用关键字var定义：

1
2

var x = 5 // `Int` type is inferred
x += 1

注释

跟Java一样，支持单行注释，使用两个斜杆。多行注释/* your comments */，使用/*和*/包裹。

1
2
3
4

// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */

字符模板

在字符串里面使用变量：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fun main(args: Array<String>) {
    var a = 1
    // simple name in template:
    val s1 = "a is $a"

    a = 2
    // arbitrary expression in template:
    val s2 = "${s1.replace("is", "was")}, but now is $a"
    println(s2)
}

条件表达式

传统的在Java里面的方法：

1
2
3
4
5
6
7

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

使用条件表达式后更加简洁。多说一句在Kotlin里面基本上所有的语句都是表达式，表达式有返回值，所以表达式可以用在任何需要值的地方，有点函数式编程的意思：

1

fun max(a: Int, b: Int) = if (a > b) a else b

可空类型，空值null检查

如果一个值有可能是空值，那么就应该标识类型为可能为空值，也就是在类型后面添加一个问号。

1
2
3

fun parseInt(str: String): Int? {
    // ...
}

如果调用了函数，返回值为可空类型时，在使用这个值的时候必须先进行检查，像下面的变量x和y

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // 如果直接使用 `x * y` 会引发一个错误，因为x和y都是可空类型，使用前必须做检查
    if (x != null && y != null) {
        // 做了null check之后x和y会自动转换成对应的对应的类型，不再是可空类型
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }
}

fun main(args: Array<String>) {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}

类型查检，自动转换

使用is或者!is来判断一个对象是否为某类型。下面的代码里面使用了Any类型，我的理解是应该可以传递任何类型的值。如果一个immutable变量或者属性为检查的类型，那么可以把那个对象直接当做受检类型使用。

1
2
3
4
5
6
7
8
9

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` is automatically cast to `String` in this branch
        return obj.length
    }

    // `obj` is still of type `Any` outside of the type-checked branch
    return null
}

或者像下面这相使用

1
2
3
4
5
6

fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null

    // `obj` is automatically cast to `String` in this branch
    return obj.length
}

或者

1
2
3
4
5
6
7
8

fun getStringLength(obj: Any): Int? {
    // `obj` is automatically cast to `String` on the right-hand side of `&&`
    if (obj is String && obj.length > 0) {
        return obj.length
    }

    return null
}

循环

在Kotlin里面使用for非常自然简洁。

1
2
3
4
5
6

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }
}

或者

1
2
3
4
5
6

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

while循环

1
2
3
4
5
6
7
8

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    var index = 0
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}

when表达式，跟其他一些语言的模式匹配差不多

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

fun describe(obj: Any): String =
when (obj) {
    1          -> "One"
    "Hello"    -> "Greeting"
    is Long    -> "Long"
    !is String -> "Not a string"
    else       -> "Unknown"
}

fun main(args: Array<String>) {
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}

范围 ranges

可以使用in检查变量是否在某个范围内

1
2
3
4
5
6
7

fun main(args: Array<String>) {
    val x = 10
    val y = 9
    if (x in 1..y+1) {
        println("fits in range")
    }
}

或者使用!in检查不在某个范围

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fun main(args: Array<String>) {
    val list = listOf("a", "b", "c")

    if (-1 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range too")
    }
}

在范围上使用循环

1
2
3
4
5

fun main(args: Array<String>) {
    for (x in 1..5) {
        print(x)
    }
}

或者

1
2
3
4
5
6
7
8

fun main(args: Array<String>) {
    for (x in 1..10 step 2) {
        print(x)
    }
    for (x in 9 downTo 0 step 3) {
        print(x)
    }
}

集合

循环集合同样非常简洁自然

1
2
3

for (item in items) {
    println(item)
}

使用in检查一个对象是否在一个集合里面

1
2
3
4
5
6
7

fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}

使用高阶函数，lambda表达式过滤，处理集合的每个元素，Java在最新的版本里面也添加了这个特性，通过Stream Api实现。it就代表集合的每个元素

1
2
3
4
5
6
7
8

fun main(args: Array<String>) {
    val fruits = listOf("banana", "avocado", "apple", "kiwi")
    fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { println(it) }
}