Kotlin for Android 基础教程

1. Kotlin 简介和特性

1.1 Kotlin 是什么？

Kotlin 是一种现代的静态类型编程语言，由 JetBrains 开发，旨在提高开发效率和代码可读性。它可以在 Java 虚拟机（JVM）上运行，并且可以编译成 JavaScript 或本地代码。Kotlin 特别适合 Android 开发，因为它与 Java 完全兼容，并且提供了许多现代语言特性。

1.2 Kotlin 的主要特性

简洁性：Kotlin 减少了样板代码，使代码更简洁易读。
空安全：Kotlin 内置了对空值的安全处理，减少了 NullPointerException 的风险。
函数式编程：Kotlin 支持高阶函数、Lambda 表达式和函数组合，使得函数式编程更加自然。
互操作性：Kotlin 与 Java 完全兼容，可以无缝调用 Java 代码，反之亦然。
协程：Kotlin 提供了轻量级的协程，简化了异步编程。

2. 开发环境搭建

2.1 安装 IntelliJ IDEA

IntelliJ IDEA 是 JetBrains 开发的一款强大的集成开发环境（IDE），特别适合 Kotlin 开发。你可以从 JetBrains 官网下载并安装 IntelliJ IDEA。

2.2 安装 Android Studio

Android Studio 是官方推荐的 Android 开发 IDE，基于 IntelliJ IDEA 构建，提供了丰富的 Android 开发工具。你可以从 Android 开发者官网下载并安装 Android Studio。

3. 第一个 Kotlin 程序

3.1 创建新项目

打开 IntelliJ IDEA 或 Android Studio。
选择 "New Project"。
选择 "Kotlin" 作为项目类型。
输入项目名称和位置，点击 "Finish"。

3.2 编写 Hello World 程序

在 src 目录下创建一个新的 Kotlin 文件 Main.kt，并编写以下代码：

fun main() {
    println("Hello, Kotlin!")
}

3.3 运行程序

点击 IDE 中的运行按钮，你将在控制台看到输出：

Hello, Kotlin!

4. 基本语法和数据类型

4.1 变量和常量

在 Kotlin 中，你可以使用 var 声明可变变量，使用 val 声明不可变常量。

var age: Int = 30
val name: String = "Alice"

4.2 数据类型

Kotlin 支持以下基本数据类型：

Int：整数
Double：双精度浮点数
String：字符串
Boolean：布尔值

val number: Int = 42
val pi: Double = 3.14
val message: String = "Hello"
val isTrue: Boolean = true

5. 条件语句

5.1 if 语句

if 语句用于条件判断。

val x = 10
if (x > 5) {
    println("x is greater than 5")
} else {
    println("x is not greater than 5")
}

5.2 when 语句

when 语句类似于 Java 中的 switch 语句，但更加强大。

val day = "Monday"
when (day) {
    "Monday" -> println("It's Monday")
    "Tuesday" -> println("It's Tuesday")
    else -> println("It's another day")
}

6. 循环

6.1 for 循环

for 循环用于遍历集合或范围。

for (i in 1..5) {
    println(i)
}

6.2 while 循环

while 循环在条件为真时重复执行代码块。

var i = 0
while (i < 5) {
    println(i)
    i++
}

6.3 do-while 循环

do-while 循环先执行代码块，再检查条件。

var i = 0
do {
    println(i)
    i++
} while (i < 5)

7. 跳转表达式

7.1 break

break 用于跳出循环。

for (i in 1..10) {
    if (i == 5) {
        break
    }
    println(i)
}

7.2 continue

continue 用于跳过当前迭代，继续下一次循环。

for (i in 1..5) {
    if (i == 3) {
        continue
    }
    println(i)
}

7.3 return

return 用于从函数中返回值。

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

8. 函数定义和调用

8.1 定义函数

使用 fun 关键字定义函数。

fun greet(name: String): String {
    return "Hello, $name!"
}

8.2 调用函数

调用函数时，传递参数并接收返回值。

val greeting = greet("Alice")
println(greeting)

9. 默认参数和命名参数

9.1 默认参数

函数参数可以有默认值。

fun greet(name: String = "Guest"): String {
    return "Hello, $name!"
}

9.2 命名参数

调用函数时，可以指定参数名称。

val greeting = greet(name = "Alice")
println(greeting)

10. 单表达式函数

10.1 单表达式函数

如果函数体只有一个表达式，可以省略大括号。

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

11. Lambda 表达式

11.1 Lambda 表达式

Lambda 表达式是一种匿名函数，可以作为参数传递。

val sum = { a: Int, b: Int -> a + b }
println(sum(1, 2))

12. 高阶函数

12.1 高阶函数

高阶函数是接受函数作为参数或返回函数的函数。

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val result = operate(3, 4) { x, y -> x * y }
println(result)

13. 类定义和实例化

13.1 类定义

使用 class 关键字定义类。

class Person(val name: String, var age: Int)

13.2 实例化

使用构造函数创建类的实例。

val person = Person("Alice", 30)
println("Name: ${person.name}, Age: ${person.age}")

14. 构造函数和初始化块

14.1 主构造函数

主构造函数在类头中定义。

class Person(val name: String, var age: Int)

14.2 初始化块

初始化块在实例化时执行。

class Person(val name: String, var age: Int) {
    init {
        println("Person initialized with name: $name and age: $age")
    }
}

15. 属性和字段

15.1 属性

属性是类的成员变量，可以有 getter 和 setter。

class Person(val name: String, var age: Int) {
    var address: String = ""
        get() = field
        set(value) {
            field = value
        }
}

16. 继承和接口

16.1 继承

使用 : 符号继承类。

open class Animal(val name: String)

class Dog(name: String) : Animal(name)

16.2 接口

使用 interface 关键字定义接口。

interface Greeter {
    fun greet(name: String): String
}

class Person(val name: String) : Greeter {
    override fun greet(name: String): String {
        return "Hello, $name!"
    }
}

17. 数据类和密封类

17.1 数据类

数据类用于存储数据，自动生成 equals、hashCode、toString 等方法。

data class User(val id: Int, val name: String)

17.2 密封类

密封类限制了类的继承层次。

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

18. 对象声明和表达式

18.1 对象声明

对象声明用于创建单例对象。

object Singleton {
    val name = "Singleton"
}

18.2 对象表达式

对象表达式用于创建匿名对象。

val greeter = object : Greeter {
    override fun greet(name: String): String {
        return "Hello, $name!"
    }
}

19. 可空类型和非空类型

19.1 可空类型

在类型后加 ? 表示可空类型。

var name: String? = null

19.2 非空类型

非空类型不能为 null。

var name: String = "Alice"

20. 安全调用操作符 (?.)

20.1 安全调用操作符

安全调用操作符 ?. 用于安全地访问可空类型的属性或方法。

val length = name?.length

21. Elvis 操作符 (?:)

21.1 Elvis 操作符

Elvis 操作符 ?: 用于提供默认值。

val length = name?.length ?: 0

22. 非空断言 (!!)

22.1 非空断言

非空断言 !! 用于强制断言变量不为 null。

val length = name!!.length

23. 平台类型

23.1 平台类型

平台类型是 Kotlin 与 Java 互操作时的一种类型，表示 Kotlin 无法确定其可空性。

val name: String! = "Alice"

24. List, Set, Map

24.1 List

List 是有序集合。

val list = listOf("Apple", "Banana", "Cherry")

24.2 Set

Set 是无序集合，不允许重复元素。

val set = setOf("Apple", "Banana", "Cherry")

24.3 Map

Map 是键值对集合。

val map = mapOf("Apple" to 1, "Banana" to 2, "Cherry" to 3)

25. 可变集合和不可变集合

25.1 可变集合

使用 mutableListOf、mutableSetOf、mutableMapOf 创建可变集合。

val mutableList = mutableListOf("Apple", "Banana", "Cherry")
mutableList.add("Date")

25.2 不可变集合

使用 listOf、setOf、mapOf 创建不可变集合。

val immutableList = listOf("Apple", "Banana", "Cherry")

26. 集合操作 (filter, map, reduce 等)

26.1 filter

filter 用于过滤集合元素。

val filteredList = list.filter { it.length > 5 }

26.2 map

map 用于转换集合元素。

val mappedList = list.map { it.toUpperCase() }

26.3 reduce

reduce 用于累积集合元素。

val sum = list.map { it.length }.reduce { acc, i -> acc + i }

27. 序列 (Sequence)

27.1 序列

Sequence 是一种惰性集合，适用于大数据集。

val sequence = sequenceOf("Apple", "Banana", "Cherry")
val filteredSequence = sequence.filter { it.length > 5 }

28. 不可变性

28.1 不可变性

不可变对象在创建后不能修改，提高了代码的安全性和可维护性。

val immutableList = listOf("Apple", "Banana", "Cherry")

29. 纯函数

29.1 纯函数

纯函数是没有副作用的函数，输出仅依赖于输入。

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

30. 函数组合

30.1 函数组合

函数组合是将多个函数组合成一个新函数。

fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int {
    return { x -> f(g(x)) }
}

31. 柯里化

31.1 柯里化

柯里化是将多参数函数转换为一系列单参数函数。

fun add(a: Int) = { b: Int -> a + b }
val add5 = add(5)
println(add5(3))

32. 协程基础

32.1 协程

协程是轻量级的线程，简化了异步编程。

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

33. 挂起函数

33.1 挂起函数

挂起函数可以暂停执行，不阻塞线程。

suspend fun fetchData(): String {
    delay(1000L)
    return "Data"
}

34. 协程上下文和调度器

34.1 协程上下文

协程上下文包含协程的调度器和其他元素。

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        println("Running on ${Thread.currentThread().name}")
    }
}

35. 通道和流

35.1 通道

通道用于协程之间的通信。

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close()
    }
    for (y in channel) println(y)
}

35.2 流

流用于处理异步数据流。

import kotlinx.coroutines.*
import kotlinx.coroutines.flow

← Previous: 14. Android 开发 Next: Android Jetpack 与 Kotlin 编程教程 →