Kotlin语言基础入门：Kotlin简介

在2019年Google I/O大会上，Google 宣布今后将优先采用 Kotlin 进行 Android 开发。

一，简介

Kotlin 是一种富有表现力且简洁的编程语言，不仅可以减少常见代码错误，还可以轻松集成到现有应用中。

Google 列举的 Kotlin 的优势：

富有表现力且简洁：可以使用更少的代码实现更多的功能。表达自己的想法，少编写样板代码。
更安全的代码：Kotlin 有许多语言功能，可帮助你避免null指针异常等常见编程错误。
可互操作：可以在 Kotlin 代码中调用 Java 代码，或者在 Java 代码中调用 Kotlin 代码。Kotlin 可完全与 Java 编程语言互操作。
结构化并发：Kotlin 协程让异步代码像阻塞代码一样易于使用。协程可大幅简化后台任务管理。

更重要的是，Jetpack Compose 仅支持 Kotlin，而不再支持 Java。 Google 提到多平台项目可使用 Kotlin 来开发。

二，概念介绍

1. 包的定义和使用

包的定义应该写在文件的顶部。

package com.rustfisher.ktpractice.intro

import kotlin.text.*

// ...

Kotlin并不要求包名和文件存放位置严格对应。

2. 程序入口

Kotlin应用的程序入口是main方法。

fun main() {
    // ..
}

另一个main方法带有参数

fun main(args: Array<String>) {
    // ...
}

3. 标准输出

print方法将传入的变量打印到标准输入流。

print("Rust ")
print("Fisher")

println打印传入变量并且在最后添加一个换行。

println("an.rustfisher.com")
println(42)

4. 方法

下面是一个接受2个Int参数，返回Int的方法。

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

方法主体可以是一个表达式。它的返回值可以被推断出来。

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

方法可以没有返回值，或者说是返回一个无意义的值(Unit)。

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

Unit可以忽略不写。

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

5. 变量

只能读的变量需要用关键字val。它们只能被赋值1次。

val a: Int = 1 // 直接赋值
val b = 2      // 自动推测出是Int类型
val c: Int     // 当没有赋初始值时，需要声明类型Type required when no initializer is provided
c = 3          // 这里是推迟赋值

可以多次赋值的变量用关键字var

var x = 5 // 自动推测出是Int型
x += 1

可以在顶部声明变量

val PI = 3.14
var x = 0

fun incrementX() { 
    x += 1
}

6. 创建类与实例

定义一个类，使用class关键字

class Fisher

类的属性可以放在定义中或者类里。比如下面这个类Rectangle，描述长方形。

class Rectangle(var height: Double, var length: Double) {
    var perimeter = (height + length) * 2
}

默认构造器中的变量可以直接使用。这里可以直接使用面积变量perimeter

val rectangle = Rectangle(5.0, 2.0)
println("The perimeter is ${rectangle.perimeter}")

对于kotlin v.1.4.30，类的继承用冒号:来表示。类默认都是final的，不可继承。为了继承，用open让这个类能被继承。

open class Shape
class Rectangle(var height: Double, var length: Double): Shape {
    var perimeter = (height + length) * 2
}

7. 注释

和其他现代编程语言类似，用//或者/**/来注释

// 这里是注释 RustFisher
/**
 * 这是注释
 */
/* 这也是注释 */

8. 字符串模版(String tempplates)

直接使用变量，用$

要使用表达式，需要用大括号${}

var a = 1
// 简单使用$
val s1 = "a is $a" 

a = 2
// 使用方法
val s2 = "${s1.replace("is", "was")}, but now is $a"

9. 条件表达式

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

Kotlin中，if也可以写成一个表达式

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

10. for循环

使用in

val items = listOf("apple", "banana", "kiwifruit")
for (item in items) {
    println(item)
}

使用下标

val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

for (i in 1..3) {
    println(i)
}
for (i in 6 downTo 0 step 2) {
    println(i)
}

11. while循环

val items = listOf("apple", "banana", "kiwifruit")
var index = 0
while (index < items.size) {
    println("item at $index is ${items[index]}")
    index++
}

12. when表达式

when看起来有点像Java里的witch，但这两个是不同的东西。

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

13. 范围

检查一个数字是否在范围中，使用in操作

val x = 10
val y = 9
if (x in 1..y+1) {
    println("在范围内")
}

检查一个数是否超出了范围

val list = listOf("a", "b", "c")

if (-1 !in 0..list.lastIndex) {
    println("-1 超出了范围")
}
if (list.size !in list.indices) {
    println("list的size也超出了下标范围")
}

遍历一个范围

for (x in 1..5) {
    print(x)
}

指定步进值

for (x in 1..10 step 2) {
    print(x)
}
println()
for (x in 9 downTo 0 step 3) {
    print(x)
}

14. 集合

遍历一个集合

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

检查集合中是否包含某个对象，用in操作

when {
    "orange" in items -> println("juicy")
    "apple" in items -> println("apple is fine too")
}

用lambda表达式对集合进行filter和map操作

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { println(it) }

15. 可为null的值和null检查

可以为null的变量，后面需要一个问号?

下面这个方法返回Int或者null

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

使用可能返回null的方法（上面那个方法）

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

    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x 和 y 经过null检测后自动变成了非null值
        println(x * y)
    }
    else {
        println("'$arg1' or '$arg2' 不是数字")
    }    
}

或者写做

// ...
if (x == null) {
    println("参数错误 arg1: '$arg1'")
    return
}
if (y == null) {
    println("参数错误 arg2: '$arg2'")
    return
}

// x 和 y 经过null检测后自动变成了非null值
println(x * y)

16. 类型检查和自动转换

用is来检查某个对象是不是某个类型。如果确定某个不可变的变量的类型，那后面使用它的时候不用再显式转换

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // obj已经自动转换为String类型
        return obj.length
    }

    // 这里的obj仍然是Any类型
    return null
}

或者用!is

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
}

文末分享：140集 Kotlin 入门到精通全系列（项目开发实战）视频教程

alt