Kotlin Bootstrap

发表于 | 更新于 | 分类于

May 17, 2017, at the Google I/O keynote, the Android team announced first-class support for Kotlin.

Android团队已经宣布为 Kotlin 提供 “first-class support”
Kotlin 官网上对应 Android 的 tutorial
Android Developers 官网上对应 Kotlin 的 start up

现在就橹一遍 “hands-on” learning 吧
希望不会像 Swift 那样

Hello, world

fun 关键字后面跟上 函数名
括号里面是 参数名: 参数类型
括号后面跟上 返回值类型 （void 就不用写）
返回值类型 后面可以跟上 ? 代表返回值可以为空

fun main(args: Array<String>) {  
    println("Hello, world!")  
}

main 函数、命令行参数什么的就略过了吧

基本语法

条件表达式

if 在 Kotlin 中是表达式，具有返回值

fun main(args: Array<String>) {
    println(max(args[0].toInt(), args[1].toInt()))
}

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

没错，函数的返回值也可以用 = 简写

Null 检查

A reference must be explicitly marked as nullable to be able hold a null.

一个引用必须被明确的标记为 nullable 以便能被赋值为 null 

package multiplier

// 如果 str 不是数字则返回 null
// 这里的问号即标记返回值可为 null
fun parseInt(str: String): Int? {
    try {
        return str.toInt()
    } catch (e: NumberFormatException) {
        println("One of the arguments isn't Int")
    }
    return null
}

fun main(args: Array<String>) {
    if (args.size < 2) {
        println("No number supplied");
    } else {
        val x = parseInt(args[0])
        val y = parseInt(args[1])

        // 不能直接写 'x * y' 因为他们还有可能为 null
        if (x != null && y != null) {
            print(x * y) // Now we can
        } else {
            println("One of the arguments is null")
        }
    }
}

听说能减少一半以上的 NullPointerException ？

is Check 和 自动 cast

使用 is 来检查某个引用是否为某种类型的实例等等
如果我们已经 check 过了某种 immutable 的类型，在之后的使用就无需将其进行类型转换 

fun main(args: Array<String>) {
    println(getStringLength("aaa"))
    println(getStringLength(1))
}

fun getStringLength(obj: Any): Int? {
    if (obj is String)
        return obj.length // 无需 cast 成 String
    return null
}

while 循环

while 和 do..while 同 java

fun main(args: Array<String>) {
    var i = 0
    while (i < args.size)
        println(args[i++])
}

for 循环

给一个 iterable 的对象就能循环

fun main(args: Array<String>) {
    for (arg in args)
        println(arg)

    // or
    println()
    for (i in args.indices)
        println(args[i])
}

range 和 in

<num1>..<num2> 返回的是一个 iterable 对象
in 操作符可以用来检查值是否在范围中，也可以在 for 循环里面 loop 

fun main(args: Array<String>) {
    val x = args[0].toInt()
    // 检查数字是否在范围内
    val y = 10
    if (x in 1..y - 1)
        println("OK")

    // 在一个范围内枚举
    for (a in 1..5)
        print("${a} ")

    // 检查数字是否超出范围
    println()
    val array = arrayListOf<String>()
    array.add("aaa")
    array.add("bbb")
    array.add("ccc")

    if (x !in 0..array.size - 1)
        println("Out: array has only ${array.size} elements. x = ${x}")

    // 检查一个 collection 是否包含某个 object
    if ("aaa" in array) // collection.contains(obj) 被调用
        println("Yes: array contains aaa")

    if ("ddd" in array) // collection.contains(obj) 被调用
        println("Yes: array contains ddd")
    else
        println("No: array doesn't contains ddd")
}

when

when 取代 java 中的 switch..case，很白话 

fun main(args: Array<String>) {
    cases("Hello")
    cases(1)
    cases(0L)
    cases(MyClass())
    cases("hello")
}

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

class MyClass() {
}

Destructuring 声明 和 Data 类

Destructuring （解构？）声明

val (name, age) = person 这样的声明可以将对象 destructure（对象并不会被销毁）成几个变量
一句 destructuring declaration 会被编译成一下代码 

val name = person.component1()
val age = person.component2()

前提是你需要在你的类中定义这样的方法（如果声明成 data 类就会自动实现 componentN 的方法）

fun main(args: Array<String>) {
    val pair = Pair(1, "one")

    val (num, name) = pair

    println("num = $num, name = $name")
}

// 泛型还是这么用没有问题的
class Pair<K, V>(val first: K, val second: V) {
    operator fun component1(): K {
        return first
    }

    operator fun component2(): V {
        return second
    }
}

data 类

将类声明为 data 类，可以由编译器自动根据主构造函数参数自动生成：

  • equals() / hashCode()
  • toString() 以 “User(name=John, age=42)” 这样的格式
  • componentN() 按照声明的顺序生成对应成员的 componentN()
  • copy() 深度拷贝？还没试

遍历 map

fun main(args: Array<String>) {
    val map = hashMapOf<String, Int>()
    map.put("one", 1)
    map.put("two", 2)

    for ((key, value) in map) {
        println("key = $key, value = $value")
    }
}