Kotlin学习大纲

Posted on In ,

Kotlin 是一种现代的静态类型编程语言，广泛用于 Android 开发、服务器端开发以及跨平台应用开发。以下是一个详细的 Kotlin 学习大纲，涵盖了从基础到高级的各个方面。

1. Kotlin 基础

1.1 环境搭建

  • 安装 Kotlin 编译器
  • 配置 IntelliJ IDEA 或 Android Studio

当然，让我带你更深入了解 Kotlin 中的基本语法。

1.2 基础语法

在 Kotlin 中，一切都是对象，这意味着我们可以调用任何类型的成员函数和属性。这也意味着，与 Java 不同，Kotlin 没有原始数据类型，这有助于避免空指针异常。

1.2.1 变量和常量

  • 变量: 使用 var 关键字声明变量，其值可以被改变。

    1
    2
    var age: Int = 30
    age = 31 // 正确

  • 常量: 使用 val 关键字声明常量，其值不可更改一旦被初始化。

    1
    2
    val name: String = "Alice"
    // name = "Bob" // 错误，不能重新赋值

Kotlin 有类型推断，所以通常不需要显式指定类型，编译器可以自动推断出变量的类型。

1.2.2 数据类型

Kotlin 的基本数据类型包括：

  • 数字类型: Byte, Short, Int, Long, Float, Double

    1
    2
    3
    4
    val intVal: Int = 123
    val longVal: Long = 123456L
    val doubleVal: Double = 12.34
    val floatVal: Float = 12.34F

  • 字符: Char

    1
    val char: Char = 'A'

  • 布尔: Boolean (只有 true 或 false)

    1
    val boolean: Boolean = true

  • 字符串: String

    1
    val string: String = "Hello, World!"
1.2.3 字符串模板

字符串模板或插值意味着在字符串中可以直接嵌入变量或表达式。

1
2
3
val name: String = "Alice"
val greeting: String = "Hello, $name!"
val sum: String = "The sum of 2 and 3 is ${2 + 3}"
1.2.4 注释

Kotlin 支持单行和多行注释。

  • 单行注释: 使用 //

    1
    // 这是一个单行注释

  • 多行注释: 使用 /* */

    1
    2
    /* 这是一个多行注释的开始
       这是一个多行注释的结束 */

注释可以嵌套。

1.2.5 空值处理

在 Kotlin 中，所有类型默认都是非空的。如果你想允许一个变量为 null，你需要明确指定它为可空类型，方法是在类型后面加一个问号 ?。

1
var name: String? = null
1.2.6 类型检查和自动类型转换

使用 is 进行类型检查，Kotlin 有智能类型转换（智能转换），如果已经进行了类型检查，就不需要显式转换。

1
2
3
4
if (obj is String) {
    // obj 在这个范围内自动转为 String 类型
    println(obj.length)
}
1.2.7 类型别名

可以给类型定义别名，方便在代码中引用。

1
2
typealias MyMap = Map<Int, String>
val map: MyMap = mapOf(1 to "one", 2 to "two")

当然，让我们深入了解 Kotlin 中的控制流结构。

1.3 控制流

控制流是编程语言中用于控制程序执行流程的结构。Kotlin 提供了多种控制流结构，包括 if 表达式、when 表达式、for 循环、while 循环和 do-while 循环。

1.3.1 if 表达式

在 Kotlin 中，if 是一个表达式，这意味着它可以返回一个值。因此，它可以用作三元运算符的替代品。

1
2
3
val a = 10
val b = 20
val max = if (a > b) a else b

if 表达式也可以有多个分支：

1
2
3
4
5
6
7
8
val number = 10
val result = if (number > 0) {
    "Positive"
} else if (number < 0) {
    "Negative"
} else {
    "Zero"
}
1.3.2 when 表达式

when 表达式是 Kotlin 中用于替代 Java 的 switch 语句的结构。它非常强大，可以用于多种情况。

1
2
3
4
5
6
7
val x = 10
when (x) {
    1 -> println("x is 1")
    2, 3 -> println("x is 2 or 3")
    in 4..10 -> println("x is between 4 and 10")
    else -> println("x is not in the range")
}

when 也可以用作表达式，返回一个值：

1
2
3
4
5
6
7
val number = 3
val result = when (number) {
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
    else -> "Other"
}
1.3.3 for 循环

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

1
2
3
4
5
6
7
8
for (i in 1..5) {
    println(i)
}

val list = listOf("apple", "banana", "cherry")
for (item in list) {
    println(item)
}

还可以使用索引遍历集合：

1
2
3
for (i in list.indices) {
    println("item at $i is ${list[i]}")
}
1.3.4 while 和 do-while 循环

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

1
2
3
4
5
var i = 0
while (i < 5) {
    println(i)
    i++
}

do-while 循环与 while 循环类似，但至少执行一次，因为条件在代码块之后检查。

1
2
3
4
5
var j = 0
do {
    println(j)
    j++
} while (j < 5)
1.3.5 跳转表达式

Kotlin 支持 break 和 continue 跳转表达式，用于控制循环的流程。

  • break 用于立即终止最内层的循环。
  • continue 用于跳过当前循环的剩余代码，并继续下一次迭代。
1
2
3
4
5
6
7
8
9
for (i in 1..10) {
    if (i == 5) break
    println(i)
}

for (i in 1..10) {
    if (i % 2 == 0) continue
    println(i)
}

1.4 函数

函数是任何编程语言中的基本构建块之一。Kotlin 提供了强大的函数定义和使用功能，使得代码更加简洁和易于维护。

1.4.1 函数定义和调用

在 Kotlin 中，函数的定义使用 fun 关键字，后面跟上函数名、参数列表以及返回类型。

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

调用函数非常简单，和其他编程语言一样：

1
2
val result = sum(5, 3)
println(result) // 输出 8
1.4.2 返回类型

如果函数不返回任何值，其返回类型为 Unit，这是 Kotlin 中的空类型，类似于 Java 中的 void。但在 Kotlin 中，返回 Unit 的函数可以省略返回类型。

1
2
3
fun printSum(a: Int, b: Int) {
    println("Sum is: ${a + b}")
}
1.4.3 默认参数和命名参数

Kotlin 支持为函数参数提供默认值，这使得函数调用更加灵活。

1
2
3
4
5
6
fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

greet("Alice") // 输出：Hello, Alice!
greet("Bob", "Hi") // 输出：Hi, Bob!

调用函数时，可以使用命名参数，这样可以明确地指定参数名称。

1
greet(name = "Charlie", greeting = "Welcome")
1.4.4 单表达式函数

如果函数只包含一个表达式，可以简化为单表达式函数，用等号 = 和表达式来代替大括号 {} 和 return 语句。

1
2
3
4
fun multiply(a: Int, b: Int): Int = a * b

// 返回类型也可以省略，如果可以推断出来
fun add(a: Int, b: Int) = a + b
1.4.5 可变参数（vararg）

Kotlin 允许函数接受可变数量的参数，使用 vararg 关键字。

1
2
3
4
5
6
7
fun printAll(vararg strings: String) {
    for (str in strings) {
        println(str)
    }
}

printAll("Hello", "World", "Kotlin", "is", "awesome!")
1.4.6 局部函数

Kotlin 支持在函数内部定义局部函数，有助于封装代码逻辑，使代码更具组织性和可读性。

1
2
3
4
5
6
7
8
9
10
11
fun outerFunction() {
    println("This is the outer function.")

    fun innerFunction() {
        println("This is the inner function.")
    }

    innerFunction()
}

outerFunction()
1.4.7 高阶函数和 Lambda 表达式

高阶函数是可以接受函数作为参数或返回函数的函数。Lambda 表达式是 Kotlin 中的一种简洁的函数定义方式。

1
2
3
4
5
6
fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val sum = operate(4, 5) { x, y -> x + y }
println(sum) // 输出 9
1.4.8 内联函数

内联函数用于消除高阶函数带来的性能开销。使用 inline 关键字可以让编译器将函数调用替换为函数体。

1
2
3
4
5
6
7
8
inline fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try {
        return body()
    } finally {
        lock.unlock()
    }
}
1.4.9 尾递归函数

Kotlin 支持尾递归函数，这是递归的一种优化方式，可以避免栈溢出。使用 tailrec 关键字。

1
2
3
4
5
tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n == 1) acc else factorial(n - 1, n * acc)
}

println(factorial(5)) // 输出 120

1.5 类和对象

Kotlin 是一种面向对象的编程语言，类和对象是其核心概念之一。Kotlin 提供了强大且灵活的类定义和使用方式，使得编写面向对象的代码更加简洁和易维护。

1.5.1 类的定义

在 Kotlin 中，使用 class 关键字来定义一个类。

1
2
3
4
class Person {
    var name: String = ""
    var age: Int = 0
}
1.5.2 构造函数

Kotlin 类可以有一个主构造函数和一个或多个次构造函数。

  • 主构造函数: 在类头部定义，紧跟在类名后面。
1
class Person(val name: String, var age: Int)
  • 次构造函数: 使用 constructor 关键字定义，可以有多个。
1
2
3
4
5
6
7
8
9
class Person {
    var name: String
    var age: Int

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}
  • 初始化块: 使用 init 关键字，可以在主构造函数中进行初始化。
1
2
3
4
5
class Person(val name: String, var age: Int) {
    init {
        println("Person is created with name $name and age $age")
    }
}
1.5.3 创建对象

使用类的主构造函数或次构造函数来创建对象。

1
2
val person1 = Person("Alice", 30)
val person2 = Person("Bob", 25)
1.5.4 属性和字段

Kotlin 类的属性可以有自定义的 getter 和 setter。

1
2
3
4
5
6
7
8
9
10
class Person {
    var name: String = ""
        get() = field.toUpperCase()
        set(value) {
            field = value.trim()
        }

    var age: Int = 0
        private set // 设为私有，外部不可修改
}
1.5.5 方法

Kotlin 类可以包含方法，方法定义和普通函数一样。

1
2
3
4
5
class Person(val name: String, var age: Int) {
    fun greet() {
        println("Hello, my name is $name and I am $age years old.")
    }
}
1.5.6 继承

在 Kotlin 中，所有类默认都是不可继承的，除非使用 open 关键字标记。继承使用 : 关键字。

1
2
3
4
5
6
7
8
9
10
11
open class Animal(val name: String) {
    open fun sound() {
        println("Animal makes a sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun sound() {
        println("Dog barks")
    }
}
1.5.7 抽象类和接口
  • 抽象类: 使用 abstract 关键字，不能实例化。可以包含抽象方法（无实现）和具体方法（有实现）。
1
2
3
4
5
6
7
8
9
abstract class Animal(val name: String) {
    abstract fun sound()
}

class Cat(name: String) : Animal(name) {
    override fun sound() {
        println("Cat meows")
    }
}
  • 接口: 使用 interface 关键字，可以包含抽象方法和默认方法（有实现）。
1
2
3
4
5
6
7
8
9
10
11
12
interface Drivable {
    fun drive()
    fun honk() {
        println("Honking!")
    }
}

class Car : Drivable {
    override fun drive() {
        println("Car is driving")
    }
}
1.5.8 数据类

数据类用于保存数据，自动生成 equals()、hashCode()、toString() 和 copy() 等方法。使用 data 关键字定义。

1
2
3
4
5
6
data class User(val name: String, val age: Int)

val user1 = User("Alice", 30)
val user2 = user1.copy(name = "Bob")
println(user1) // 输出: User(name=Alice, age=30)
println(user2) // 输出: User(name=Bob, age=30)
1.5.9 单例对象

Kotlin 使用 object 关键字定义单例对象。

1
2
3
4
5
6
7
8
object Database {
    var url: String = "localhost"
    fun connect() {
        println("Connecting to $url")
    }
}

Database.connect()
1.5.10 内部类和嵌套类
  • 嵌套类: 默认情况下，嵌套类是静态的。
1
2
3
4
5
6
7
8
9
10
class Outer {
    private val name: String = "Outer"

    class Nested {
        fun greet() = "Hello from Nested"
    }
}

val nested = Outer.Nested().greet()
println(nested) // 输出: Hello from Nested
  • 内部类: 使用 inner 关键字，持有外部类的引用。
1
2
3
4
5
6
7
8
9
10
class Outer {
    private val name: String = "Outer"

    inner class Inner {
        fun greet() = "Hello from Inner, accessing $name"
    }
}

val inner = Outer().Inner().greet()
println(inner) // 输出: Hello from Inner, accessing Outer

1.6 数据类

  • 数据类的定义
  • 自动生成的函数（equals, hashCode, toString, copy）

1.7 集合

在 Kotlin 中，集合主要指的是一系列提供存储和管理对象组（元素）的类和接口。Kotlin 集合分为两大类：可变集合（Mutable）和不可变集合（Read-only）。

Kotlin 集合的接口继承结构来自 Java 集合框架，但 Kotlin 在此基础上增加了更多功能性和方便性的扩展。

1.7.1 集合类型
  • List: 有序集合，可以存储重复元素。
  • Set: 无序集合，不会存储重复元素。
  • Map: 键值对集合，键是唯一的。
1.7.2 不可变集合（Read-only）

不可变集合只能读取数据，不能修改。创建不可变集合的方法：

1
2
3
val immutableList = listOf("a", "b", "c")
val immutableSet = setOf(1, 2, 3)
val immutableMap = mapOf("key1" to "value1", "key2" to "value2")

不可变集合是只读的，但它的内容可能会改变，如果它持有的是可变对象的引用。

1.7.3 可变集合（Mutable）

可变集合允许添加、删除和修改其元素。

1
2
3
4
5
6
7
val mutableList = mutableListOf("a", "b", "c")
val mutableSet = mutableSetOf(1, 2, 3)
val mutableMap = mutableMapOf("key1" to "value1", "key2" to "value2")

mutableList.add("d") // 添加元素到 List
mutableSet.remove(1) // 从 Set 中删除元素
mutableMap.put("key3", "value3") // 向 Map 中添加键值对
1.7.4 集合操作

Kotlin 提供了丰富的标准库函数，用于对集合进行操作：

  • 转换操作: 如 map, filter, sortedBy 等。
  • 聚合操作: 如 sum, max, min, count 等。
  • 序列操作: 通过 asSequence 可以将集合转化为惰性求值的序列。
  • 集合加减操作: 可以使用 + 和 - 对集合进行元素的添加和移除。
1
2
3
4
5
6
7
val filteredList = immutableList.filter { it != "b" } // 过滤操作
val mappedList = immutableList.map { it.toUpperCase() } // 转换操作

val sumOfSet = immutableSet.sum() // 求和操作
val sortedMap = immutableMap.toSortedMap() // 排序 Map

val sequence = mutableList.asSequence().map { it.length }.filter { it > 1 }
1.7.5 集合的可变性转换

可以在不可变集合和可变集合之间进行转换：

1
2
val toMutableList = immutableList.toMutableList() // 不可变 List 转为可变
val toImmutableList = mutableList.toList() // 可变 List 转为不可变
1.7.6 迭代集合

可以使用 for 循环或迭代器来遍历集合：

1
2
3
4
5
6
7
8
9
for (item in immutableList) {
    println(item)
}

val iterator = mutableSet.iterator()
while (iterator.hasNext()) {
    val next = iterator.next()
    println(next)
}
1.7.7 解构声明

在 Kotlin 中，可以使用解构声明来方便地处理集合元素：

1
2
3
4
5
6
7
8
9
val (first, second, third) = immutableList
println(first) // 输出 a
println(second) // 输出 b
println(third) // 输出 c

// 对 Map 的解构
for ((key, value) in immutableMap) {
    println("$key -> $value")
}
1.7.8 集合的函数式API

Kotlin 的集合 API 大量采用了函数式风格，这意味着你可以使用链式调用来组合多个操作：

1
2
3
4
5
val result = immutableList
    .asSequence()
    .filter { it.startsWith("a") }
    .map { it.toUpperCase() }
    .toList()

这样的处理方式可以让你的集合操作更加简洁、清晰，同时能够有效地管理资源，特别是在处理大型集合或者复杂的数据处理流程时。

2. 高级特性

2.1 扩展函数和属性

扩展函数和扩展属性是 Kotlin 中非常强大和灵活的特性，允许你向现有的类（包括标准库中的类或其他第三方库中的类）添加新的函数和属性，而不需要修改类的源代码或继承类。

2.1.1 扩展函数

扩展函数允许你为一个类定义新的函数，即使你无法访问这个类的源代码。扩展函数的定义方式是在函数名前加上类名和点操作符。

1
2
3
4
5
6
7
8
// 为 String 类添加一个扩展函数，计算字符串的长度（不包括空格）
fun String.countNonSpaceChars(): Int {
    return this.filter { it != ' ' }.length
}

// 使用扩展函数
val str = "Hello, World!"
println(str.countNonSpaceChars()) // 输出 12

在扩展函数中，this 关键字指向调用该函数的对象（即接收者对象）。

2.1.2 扩展属性

扩展属性允许你为一个类定义新的属性。与扩展函数类似，扩展属性也不能访问类的私有或保护成员。

1
2
3
4
5
6
7
8
9
// 为 String 类添加一个扩展属性，表示字符串是否为空
val String.isEmptyOrNull: Boolean
    get() = this == null || this.isEmpty()

// 使用扩展属性
val str1 = "Hello"
val str2: String? = null
println(str1.isEmptyOrNull) // 输出 false
println(str2.isEmptyOrNull) // 输出 true

扩展属性必须定义 getter 方法，因为它们没有支持字段（backing field）。

2.1.3 扩展函数的静态解析

扩展函数是静态解析的，这意味着它们不是在运行时动态绑定到对象上的，而是在编译时根据声明的类型确定的。因此，扩展函数不会覆盖类的成员函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
open class Shape

class Circle : Shape()

fun Shape.getName() = "Shape"
fun Circle.getName() = "Circle"

fun printName(shape: Shape) {
    println(shape.getName())
}

val circle = Circle()
printName(circle) // 输出 Shape，因为扩展函数是静态解析的
2.1.4 可空接收者

扩展函数和扩展属性可以定义为可空接收者，这意味着它们可以被应用到可能为 null 的对象上。

1
2
3
4
5
6
7
8
// 为 String? 类型添加一个扩展函数，如果字符串为 null，则返回 "null"
fun String?.orNull(): String {
    return this ?: "null"
}

// 使用扩展函数
val str: String? = null
println(str.orNull()) // 输出 "null"
2.1.5 扩展的作用域

扩展函数和扩展属性必须在作用域内才能被调用。通常，你会将它们定义在顶层文件中，这样它们就可以在整个模块中使用。

1
2
3
4
5
6
7
8
// 在顶层文件中定义扩展函数
fun Int.isEven(): Boolean {
    return this % 2 == 0
}

// 在其他文件中使用扩展函数
val number = 4
println(number.isEven()) // 输出 true
2.1.6 扩展与成员的优先级

如果一个类的成员函数和扩展函数具有相同的名称和签名，成员函数总是优先。

1
2
3
4
5
6
7
8
9
10
11
12
class Example {
    fun printMessage() {
        println("Member function")
    }
}

fun Example.printMessage() {
    println("Extension function")
}

val example = Example()
example.printMessage() // 输出 "Member function"

2.2 空安全

Kotlin 的空安全特性是其核心功能之一，旨在消除 NullPointerException（NPE），从而使代码更加健壮和安全。Kotlin 通过类型系统中的可空类型和非空类型来实现这一点。

2.2.1 可空类型和非空类型

在 Kotlin 中，类型默认是非空的。如果一个变量可以为 null，则必须显式地将其类型标记为可空类型。

1
2
var nonNullString: String = "Hello"
var nullableString: String? = null
  • nonNullString 是一个非空字符串，不能赋值为 null。
  • nullableString 是一个可空字符串，可以赋值为 null。
2.2.2 安全调用操作符（?.）

安全调用操作符 ?. 允许你在不引发 NPE 的情况下调用可空对象的方法或访问其属性。如果对象为 null，则整个表达式的结果为 null。

1
2
val length: Int? = nullableString?.length
println(length) // 输出 null
2.2.3 Elvis 操作符（?:）

Elvis 操作符 ?: 提供了一种简便的方式来处理可能为 null 的值。如果左侧的表达式不为 null，则返回其值；否则返回右侧的表达式。

1
2
val lengthOrDefault: Int = nullableString?.length ?: 0
println(lengthOrDefault) // 输出 0
2.2.4 非空断言操作符（!!）

非空断言操作符 !! 用于强制将可空类型转换为非空类型。如果对象为 null，则会抛出 NullPointerException。

1
val length: Int = nullableString!!.length // 如果 nullableString 为 null，会抛出 NPE
2.2.5 安全类型转换（as?）

安全类型转换操作符 as? 尝试将对象转换为目标类型，如果转换失败，则返回 null。

1
2
3
val number: Any = 123
val str: String? = number as? String
println(str) // 输出 null
2.2.6 延迟初始化属性（lateinit）

对于某些属性，你可能希望在构造函数之外进行初始化。Kotlin 提供了 lateinit 关键字，允许你声明一个非空属性，并在稍后进行初始化。

1
2
3
4
5
lateinit var name: String

fun initializeName() {
    name = "Kotlin"
}

注意，使用 lateinit 属性时，必须确保在使用前已经进行了初始化，否则会抛出 UninitializedPropertyAccessException。

2.2.7 可空类型的扩展函数

你可以为可空类型定义扩展函数，以便在对象为 null 时执行特定的逻辑。

1
2
3
4
5
6
fun String?.printWithDefault(default: String) {
    println(this ?: default)
}

val nullableString: String? = null
nullableString.printWithDefault("Default Value") // 输出 "Default Value"
2.2.8 空安全的集合操作

Kotlin 的标准库提供了许多空安全的集合操作函数，例如 filterNotNull，它可以过滤掉集合中的 null 元素。

1
2
3
val list: List<String?> = listOf("a", null, "b")
val nonNullList: List<String> = list.filterNotNull()
println(nonNullList) // 输出 [a, b]

2.3 高阶函数和 Lambda 表达式

高阶函数和 Lambda 表达式是 Kotlin 函数式编程的重要组成部分。它们使得代码更加简洁、灵活和可重用。

2.3.1 高阶函数

高阶函数是可以接受函数作为参数或返回一个函数的函数。Kotlin 中的函数是一等公民，这意味着你可以像处理任何其他变量一样处理函数。

接受函数作为参数
1
2
3
4
5
6
7
fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

val sum = { a: Int, b: Int -> a + b }
val result = calculate(3, 4, sum)
println(result) // 输出 7

在上面的示例中，calculate 函数接受一个函数 operation 作为参数，这个函数接受两个 Int 参数并返回一个 Int。

返回函数
1
2
3
4
5
6
7
8
9
10
fun getOperation(operator: String): (Int, Int) -> Int {
    return when (operator) {
        "+" -> { a, b -> a + b }
        "-" -> { a, b -> a - b }
        else -> throw UnsupportedOperationException("Operator is not supported")
    }
}

val operation = getOperation("+")
println(operation(3, 4)) // 输出 7

getOperation 函数根据传入的操作符返回相应的函数。

2.3.2 Lambda 表达式

Lambda 表达式是一种简洁的函数表示形式，可以作为参数传递给高阶函数。Lambda 表达式的语法如下：

1
{ 参数列表 -> 函数体 }
示例
1
2
val sumLambda: (Int, Int) -> Int = { x, y -> x + y }
println(sumLambda(3, 4)) // 输出 7

Lambda 表达式可以省略参数类型，如果可以从上下文推断出来的话。

1
2
val sumLambda = { x: Int, y: Int -> x + y }
println(sumLambda(3, 4)) // 输出 7
2.3.3 Lambda 表达式中的上下文对象

Lambda 表达式可以使用捕获的外部变量和上下文对象。

1
2
3
4
5
var counter = 0
val incrementCounter = { counter += 1 }

incrementCounter()
println(counter) // 输出 1
2.3.4 匿名函数

匿名函数与 Lambda 表达式类似，但是可以指定返回类型，并且可以在函数体内使用 return 来提前返回。

1
2
3
4
5
val sum = fun(x: Int, y: Int): Int {
    return x + y
}

println(sum(3, 4)) // 输出 7
2.3.5 函数类型

在 Kotlin 中，函数类型的表示方式为 (参数类型) -> 返回类型。例如，表示两个 Int 参数并返回 Int 的函数类型如下：

1
val sum: (Int, Int) -> Int = { x, y -> x + y }
2.3.6 内联函数（inline）

内联函数是为了解决高阶函数的性能开销问题。使用 inline 关键字，可以将函数内联到调用处，从而减少函数调用的开销。

1
2
3
4
5
6
inline fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

val sum = performOperation(3, 4) { a, b -> a + b }
println(sum) // 输出 7
2.3.7 函数引用

你可以使用函数引用的方式来简化代码。函数引用的语法是 ::函数名。

1
2
3
4
5
6
fun add(a: Int, b: Int): Int {
    return a + b
}

val sum = ::add
println(sum(3, 4)) // 输出 7

你还可以引用类的成员函数和扩展函数：

1
2
3
4
5
6
7
8
9
class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
}

val calculator = Calculator()
val sum = calculator::add
println(sum(3, 4)) // 输出 7

通过高阶函数和 Lambda 表达式，Kotlin 提供了强大的函数式编程能力，使得代码更具表现力和灵活性。这些特性广泛应用于 Kotlin 标准库和各种框架中，极大地提升了代码的可读性和可维护性。

2.4 内联函数

  • 内联函数的定义和使用
  • noinline 和 crossinline

2.5 协程（Coroutines）

Kotlin 的协程提供了一种简洁、高效的异步编程方式，使得编写异步代码像编写同步代码一样简单。协程是轻量级的线程，可以简化异步编程，避免了回调地狱和复杂的线程管理。

2.5.1 协程基础

协程是一种可以在执行过程中暂停并稍后恢复执行的计算。协程的核心概念包括挂起函数、协程作用域和协程构建器。

挂起函数（Suspending Functions）

挂起函数是可以在执行过程中挂起（暂停）并稍后恢复的函数。它们使用 suspend 关键字标识。

1
2
3
4
5
suspend fun doSomething() {
    // 模拟长时间运行的任务
    delay(1000L)
    println("Task completed")
}

delay 是一个挂起函数，它不会阻塞线程，而是挂起协程，允许其他协程继续执行。

协程构建器

协程构建器用于启动协程。常见的构建器包括 launch 和 async。

  • launch：启动一个新协程并返回一个 Job 对象，执行的结果不会返回给调用者。
  • async：启动一个新协程并返回一个 Deferred 对象，结果可以通过 await 方法获取。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        doSomething()
    }
    
    val result = async {
        performCalculation()
    }
    
    println("Calculation result: ${result.await()}")
}

suspend fun doSomething() {
    delay(1000L)
    println("Task completed")
}

suspend fun performCalculation(): Int {
    delay(1000L)
    return 42
}

在上述示例中，runBlocking 是一个将当前线程阻塞的构建器，用于在主函数中启动协程。

协程作用域（Coroutine Scope）

协程作用域控制协程的生命周期。常见的作用域包括 GlobalScope 和自定义作用域。

  • GlobalScope：生命周期与应用程序相同，通常不推荐使用。
  • 自定义作用域：通过 CoroutineScope 类创建，推荐使用。
1
2
3
4
5
6
fun main() = runBlocking {
    val scope = CoroutineScope(Dispatchers.Default)
    scope.launch {
        doSomething()
    }
}
2.5.2 协程调度器（Dispatchers）

协程调度器用于指定协程在哪个线程或线程池中执行。常见的调度器包括：

  • Dispatchers.Default：使用共享的后台线程池执行协程，适合CPU密集型任务。
  • Dispatchers.IO：使用共享的后台线程池执行协程，适合IO密集型任务。
  • Dispatchers.Main：用于在主线程中执行协程，适合UI相关任务。
  • Dispatchers.Unconfined：协程在调用者线程中执行，直到第一次挂起。
1
2
3
4
5
6
7
8
9
fun main() = runBlocking {
    launch(Dispatchers.Default) {
        doSomething()
    }
    
    launch(Dispatchers.IO) {
        performCalculation()
    }
}
2.5.3 协程上下文与作业（Job）

协程上下文包括调度器和作业。Job 是协程的生命周期管理工具。

1
2
3
4
5
6
7
8
fun main() = runBlocking {
    val job = launch {
        doSomething()
    }
    
    job.join() // 等待协程完成
    println("Main coroutine continues")
}

你可以使用 job.cancel() 来取消协程。

2.5.4 协程作用域构建器

Kotlin 提供了一些内置的协程作用域构建器，如 runBlocking、coroutineScope 和 supervisorScope。

  • runBlocking：阻塞当前线程，直到协程执行完成。
  • coroutineScope：不阻塞当前线程，等待子协程执行完成。
  • supervisorScope：类似于 coroutineScope，但子协程失败不会影响其他子协程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
fun main() = runBlocking {
    coroutineScope {
        launch {
            doSomething()
        }
    }

    supervisorScope {
        val job1 = launch {
            throw Exception("Job failed")
        }
        val job2 = launch {
            performCalculation()
        }
    }
}
2.5.5 通道（Channels）

通道用于在协程之间传递数据。它类似于阻塞队列，但更适用于协程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fun main() = runBlocking {
    val channel = Channel<Int>()
    
    launch {
        for (i in 1..5) {
            channel.send(i)
        }
        channel.close()
    }
    
    for (i in channel) {
        println(i)
    }
}
2.5.6 流（Flows）

流提供了一种冷的异步数据流生成方式，类似于 RxJava 的 Observable。

1
2
3
4
5
6
7
8
9
10
11
12
fun main() = runBlocking {
    simpleFlow().collect { value ->
        println(value)
    }
}

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(100)
        emit(i)
    }
}

2.6 泛型（Generics）

泛型是编程语言中的一个特性，允许我们编写在多种数据类型上都能工作的类和函数，同时还保持类型安全。泛型在 Kotlin 中的使用与 Java 类似，但也有它自己的一些特性和优化。

2.6.1 泛型类和函数

泛型可以应用在类或者函数上，以实现高度的代码复用。以下是一个简单的泛型类示例：

1
2
3
4
5
6
class Box<T>(t: T) {
    var value = t
}

val intBox = Box(1)
val stringBox = Box("Hello")

在这个例子中，T 是一个类型参数，可以在创建 Box 类的实例时用具体的类型替换。

泛型函数的示例：

1
2
3
4
5
fun <T> singletonList(item: T): List<T> {
    return listOf(item)
}

val singleList = singletonList(1)

<T> 表示函数 singletonList 是泛型的，其中 T 是类型参数，它在调用函数时被实际的类型替换。

2.6.2 类型投影（Type Projections）

在 Kotlin 中，我们使用 in 和 out 关键字来表示类型是用于生产（out）还是消费（in）。

  • out 关键字表示一个类型参数是协变的，只能用作返回，不能作为函数的输入参数。
  • in 关键字表示一个类型参数是逆变的，只能用作输入，不能作为返回类型。

例如：

1
2
3
4
5
6
7
8
9
10
11
class Producer<out T>(private val value: T) {
    fun get(): T {
        return value
    }
}

class Consumer<in T> {
    fun consume(item: T) {
        // ...
    }
}
2.6.3 泛型约束

在 Kotlin 中，你可以限制泛型类型参数必须满足某种类型约束。例如：

1
2
3
4
5
6
7
8
9
10
fun <T : Number> List<T>.sum(): T {
    // ...
}

fun <T> ensureTrailingPeriod(seq: T)
    where T : CharSequence, T : Appendable {
    if (!seq.endsWith('.')) {
        seq.append('.')
    }
}

上面第一个函数 sum 只能被应用于数字类型的列表。第二个函数 ensureTrailingPeriod 有多个约束条件，要求 T 必须实现 CharSequence 和 Appendable 接口。

2.6.4 类型擦除

Kotlin 泛型在运行时会受到类型擦除的影响，这意味着在运行时你不能准确知道泛型的具体类型。不过，通过内联函数配合 reified 关键字，Kotlin 允许你在运行时访问泛型类型信息。

1
2
3
4
inline fun <reified T> isA(value: Any) = value is T

val item = "Hello"
println(isA<String>(item)) // 输出 true
2.6.5 星投影（Star Projection）

当你不确定或者不关心泛型的具体类型参数时，可以使用星号（*）来代替类型参数。

1
2
3
4
5
6
7
8
9
fun printList(list: List<*>) {
    list.forEach { println(it) }
}

val intList: List<Int> = listOf(1, 2, 3)
val stringList: List<String> = listOf("a", "b", "c")

printList(intList)
printList(stringList)

星投影语法用 List<*> 代表了一个未知类型的列表。

2.7 注解

  • 注解的定义和使用
  • 元注解
  • 注解处理器

2.8 反射

  • 反射的基本概念
  • 获取类和成员信息
  • 调用函数和访问属性

3. 应用开发

3.1 Android 开发

  • Android 开发环境搭建
  • 使用 Kotlin 进行 Android 开发
  • Kotlin 与 Android Jetpack
  • Kotlin 协程在 Android 中的应用

3.2 服务器端开发

  • Kotlin 与 Spring Boot
  • Kotlin 与 Ktor
  • Kotlin 与数据库交互（JDBC, ORM 等）

3.3 跨平台开发

  • Kotlin Multiplatform
  • Kotlin Native
  • Kotlin 与 React Native

4. 最佳实践和工具

4.1 代码风格和规范

  • Kotlin 代码风格指南
  • 使用 ktlint 进行代码检查

4.2 测试

  • 单元测试（JUnit, KotlinTest）
  • 集成测试
  • 使用 MockK 进行 mocking

4.3 性能优化

  • 内存管理
  • 避免常见的性能陷阱
  • 使用 Profiler 进行性能分析

4.4 工具和库

  • Kotlin 标准库
  • 常用第三方库（Retrofit, Moshi, Dagger 等）
  • 构建工具（Gradle, Maven）

5. 实战项目

5.1 小型项目

  • 命令行工具
  • 简单的 Web 应用

5.2 中型项目

  • Android 应用
  • 后端服务

5.3 大型项目

  • 复杂的 Android 应用
  • 分布式系统

通过这个大纲，你可以系统地学习 Kotlin 语言的各个方面，从基础语法到高级特性，再到实际应用开发。每个阶段都有详细的内容和目标，帮助你逐步掌握 Kotlin 编程。