Kotlin

官网 | 官方PlayGround | 中文网站

Android Kotlin | google教程

Kotlin面试 | 进程，线程，协程，管程，纤程

字符串 | lambda表达式 | 循环 | WebView

基础

Kotlin 介绍

1. Kotlin 的市场地位和影响

在 Android 开发领域，Kotlin 已经成为事实上的标准。Google 在 2019 年宣布 Kotlin First，推荐所有新项目使用 Kotlin。据统计，2025 年超过 80% 的 Android 应用在使用 Kotlin 开发。国内外大厂如字节跳动、阿里巴巴、美团的 Android 项目都在从 Java 迁移到 Kotlin。掌握 Kotlin 已经成为 Android 开发者的必备技能。

2. Kotlin 在后端开发的应用

除了 Android 开发，Kotlin 也可以用于后端开发。Spring Boot 从 5.0 版本开始就完美支持 Kotlin，很多团队在使用 Kotlin + Spring Boot 开发后端服务。相比 Java，Kotlin 开发后端的优势是代码更简洁、空安全能减少线上问题、协程能提升并发性能。虽然市场份额还不如 Java，但在一些追求技术体验的团队中越来越流行。

3. Kotlin 协程的革命性价值

Kotlin 协程是它最重要的特性之一。在 Android 开发中，协程已经取代了传统的 AsyncTask、RxJava 等异步方案。协程的优势在于轻量级、易用、支持结构化并发。一个线程可以运行成千上万个协程，而且协程的代码看起来就像同步代码一样清晰，不会陷入回调地狱。Google 官方推荐在 Android 中使用协程处理所有异步任务。

4. 学习 Kotlin 的建议

如果你有 Java 基础，学习 Kotlin 会很快，很多概念是相通的。建议重点学习 Kotlin 和 Java 的不同之处，比如空安全、扩展函数、数据类、协程等。如果是零基础，也可以直接学 Kotlin，因为 Kotlin 的语法比 Java 更简洁易懂。学习时要结合实际项目练习，边做 Android 应用边巩固 Kotlin 知识。

Kotlin 作为 Android 开发的官方语言，在市场上的需求越来越大。掌握 Kotlin 不仅能提升你的开发效率，也能大大增加你的就业竞争力。在面试中，展现出对 Kotlin 核心特性的理解，特别是空安全和协程，会让面试官眼前一亮。

Kotlin 有哪些特点？

Kotlin 是 JetBrains 公司在 2011 年推出的现代编程语言，2017 年被 Google 宣布为 Android 开发的官方首选语言。它最大的特点就是简洁、安全、实用，被称为"更好的 Java"。

Kotlin 的核心特点可以总结为几个方面。首先是简洁性，相比 Java，Kotlin 的代码量通常能减少 40% 以上，很多 Java 中需要大量模板代码的场景，在 Kotlin 中几行就能搞定。其次是空安全，Kotlin 的类型系统区分可空类型和非空类型，能在编译期就避免空指针异常，这是 Java 长期以来的痛点。第三是 100% 互操作性，Kotlin 可以和 Java 代码无缝混用，可以在现有 Java 项目中逐步引入 Kotlin。

Kotlin 和 Java 有什么区别？

Kotlin 和 Java 的区别主要体现在几个方面。语法上，Kotlin 更简洁现代，支持类型推断、默认参数、扩展函数等特性。安全性上，Kotlin 从语言层面解决了空指针问题，而 Java 需要程序员自己小心处理。并发编程上，Kotlin 提供了协程这个杀手级特性，让异步编程变得简单优雅，而 Java 传统的线程模型相对笨重。函数式编程上，Kotlin 对函数式编程的支持更好，Lambda 表达式更简洁，集合操作更方便。

用一个简单的例子来对比，Kotlin 的数据类只需要一行代码就能实现 Java 需要几十行代码才能完成的功能

// Kotlin 代码示例：简洁的数据类
data class User(val name: String, val age: Int)

// Java 需要写大量的 getter、setter、equals、hashCode、toString

Kotlin 中 val 和 var 有什么区别？

val 和 var 是 Kotlin 中声明变量的两种方式，区别很简单：val 是只读的，var 是可变的。

val 是 value 的缩写，用它声明的变量只能赋值一次，之后就不能修改了，类似 Java 中的 final 变量。一旦初始化完成，这个引用就固定了。

需要注意的是，val 只是引用不可变，如果引用的是一个可变对象（比如 MutableList），对象内部的内容还是可以修改的。

var 是 variable 的缩写，用它声明的变量可以随时重新赋值，就是普通的可变变量。

val 和 var 各自的使用场景是什么？

在使用场景上，Kotlin 推荐优先使用 val。这是函数式编程的思想，不可变数据能让代码更安全、更容易理解。

只有当你确实需要修改变量时，才使用 var。在实际开发中，大约 70% 的情况用 val 就够了。

val name = "张三"  // 只读变量，不能修改
// name = "李四"  // 编译错误

var age = 25       // 可变变量，可以修改
age = 26           // OK

val list = mutableListOf(1, 2, 3)  // val 引用不可变
list.add(4)        // 但对象内容可以修改
// list = mutableListOf(5, 6)  // 引用不能改

为什么优先使用 val

优先使用 val 不只是 Kotlin 的建议，也是函数式编程的最佳实践。不可变数据有很多好处：首先是线程安全，多个线程同时访问 val 变量不需要加锁。其次是代码更容易理解，看到 val 你就知道这个值不会变，不用担心在代码的其他地方被修改。第三是减少 bug，很多 bug 都是因为变量在不该变的时候被修改了。

val 和 const val 的区别

Kotlin 还有一个 const val，用于声明编译期常量。const val 只能用于基本类型和字符串，而且必须在顶层或 object 中声明。const val 的值在编译时就确定了，会被内联到使用的地方，性能更好。val 的值可以在运行时计算，更灵活但性能稍差。

const val MAX_SIZE = 100  // 编译期常量
val currentTime = System.currentTimeMillis()  // 运行时确定

val 和 Java final 的对应关系

如果你熟悉 Java，可以把 val 理解为自动加了 final 的变量。不过 Kotlin 的 val 更强大，因为 Kotlin 的类型推断让你不用写类型，代码更简洁。而且 Kotlin 默认鼓励使用 val，而 Java 开发者经常忘记加 final。

val 和 var 实际开发中的使用建议

在实际开发中，养成优先用 val 的习惯。一开始声明变量时用 val，如果后面发现确实需要修改，再改成 var。这种做法能让你的代码更加健壮。在 Android 开发中，ViewBinding、数据类、函数参数等场景都推荐用 val。只有像循环计数器、缓存变量这些明确需要修改的场景才用 var。

Kotlin 的类型系统

1. Kotlin 的类型系统更统一

Kotlin 的设计理念是"一切皆对象"，这让类型系统更统一、更容易理解。你可以对任何类型调用方法，比如 10.toString()、true.not()。这在 Java 中是做不到的，因为基本类型不是对象。这种统一性让 Kotlin 的泛型使用更简单，不需要像 Java 那样区分泛型和基本类型。

2. 性能优化的智能处理

虽然 Kotlin 中一切都是对象，但不用担心性能问题。Kotlin 编译器很聪明，会根据使用场景自动优化。如果一个 Int 变量不需要装箱，编译器会把它编译成 Java 的 int，性能和 Java 一样。只有在必要时（比如作为泛型参数、可空类型）才会装箱成 Integer。这种优化对开发者是透明的。

3. 可空类型的支持

Kotlin 的类型系统还区分可空类型和非空类型。Int 是非空的，Int? 是可空的。这是 Kotlin 空安全的基础。在 Java 中，所有对象类型都可能为 null，但基本类型不行，这种不一致性容易出问题。Kotlin 统一了处理方式，任何类型都可以加 ? 变成可空类型。

val notNull: Int = 100      // 不能为 null
val nullable: Int? = null   // 可以为 null

4. 字符串模板的强大之处

Kotlin 的字符串模板不只是简单的变量插入，还支持表达式。在 Java 中拼接字符串经常要写一堆加号，代码很乱。Kotlin 的字符串模板让代码更清晰，而且性能也不差，编译器会优化成 StringBuilder。

val name = "张三"
val age = 25
// 简单变量
val msg1 = "姓名：$name"
// 表达式
val msg2 = "明年 ${age + 1} 岁"
// 调用方法
val msg3 = "大写：${name.uppercase()}"

Kotlin 的基本数据类型有哪些？

Kotlin 的基本数据类型包括整数类型（Byte、Short、Int、Long）、浮点类型（Float、Double）、字符类型（Char）、布尔类型（Boolean）和字符串类型（String）。

Kotlin 的基本数据类型和Java 有什么不同？

看起来和 Java 差不多，但实际上有很大不同。最大的不同是 Kotlin 中一切都是对象，没有 Java 那种基本类型和包装类型的区分。在 Java 中，int 是基本类型，Integer 是包装类型，两者不能混用，还要考虑装箱拆箱的性能问题。在 Kotlin 中，只有 Int 这一种类型，编译器会根据使用场景自动决定是用 Java 的 int 还是 Integer，开发者不用操心。

另一个重要区别是类型名称的首字母大写。Java 的基本类型是小写的（int、boolean），Kotlin 的类型都是大写开头的（Int、Boolean）。这不只是命名习惯的区别，而是体现了 Kotlin 把它们当作对象类型来对待。

Kotlin 还有一些便利特性。比如数字类型支持下划线分隔（1_000_000），提高可读性。类型转换必须显式调用方法（toInt()、toLong()），避免隐式转换带来的问题。字符串模板让字符串拼接更简洁（"Hello $name"）。

// Kotlin 中的数字类型
val intNum: Int = 100
val longNum: Long = 100L
val doubleNum: Double = 3.14
val readableNum = 1_000_000  // 支持下划线分隔

// 类型转换必须显式
val a: Int = 10
val b: Long = a.toLong()  // 必须显式转换
// val b: Long = a  // 编译错误

// 字符串模板
val name = "张三"
val message = "你好，$name"  // 不用拼接

Kotlin 中的字符串模板是什么？如何使用？

字符串模板是 Kotlin 提供的一种便捷的字符串拼接方式，让你可以在字符串中直接嵌入变量和表达式，不用像 Java 那样用加号拼接或者 String.format()。

基本用法很简单，在字符串中用 符号加变量名就能插入变量的值。如果要插入表达式，用符号加变量名就能插入变量的值。如果要插入表达式，用{表达式} 的形式。这种写法比 Java 的字符串拼接简洁很多，代码可读性也更好。

val name = "张三"
val age = 25

// 简单变量插入
val msg1 = "你好，$name"
println(msg1)  // 输出：你好，张三

// 表达式插入
val msg2 = "明年你 ${age + 1} 岁"
println(msg2)  // 输出：明年你 26 岁

// 调用方法
val msg3 = "姓名长度：${name.length}"
println(msg3)  // 输出：姓名长度：2

需要注意的是，如果要输出 符号本身，需要转义：\。另外，在 ${} 中可以写任意合法的 Kotlin 表达式，包括函数调用、属性访问、甚至是 if 表达式。

1. 字符串模板的性能

可能有人担心字符串模板的性能问题，实际上不用担心。Kotlin 编译器会把字符串模板优化成 StringBuilder 的 append 操作，性能和手写的 Java 代码一样。所以放心用，不会有性能损失。

2. 多行字符串和模板的结合

Kotlin 支持三引号的多行字符串（""" ... """），结合字符串模板能写出非常清晰的 SQL、JSON 等格式。

val tableName = "users"
val sql = """
    SELECT * 
    FROM $tableName
    WHERE age > 20
    ORDER BY name
""".trimIndent()

3. 何时使用花括号

简单的变量名可以直接用 name，但有时候必须用name，但有时候必须用{}。比如变量名后面紧跟其他字符时，或者要插入表达式时。建议养成习惯，复杂情况都用 ${}，避免歧义。

val price = 100
// 如果不加 {}，Kotlin 会认为变量名是 price元
val msg1 = "${price}元"  // 正确
// val msg2 = "$price元"  // 错误

// 表达式必须用 {}
val msg3 = "总价：${price * 3}"

4. 字符串模板在实际开发中的应用

在 Android 开发中，字符串模板经常用于拼接 UI 文本、日志输出、网络请求参数等场景。相比 Java 的 + 拼接或 String.format()，字符串模板更直观、更不容易出错。特别是需要拼接多个变量时，字符串模板的优势更明显。

Kotlin 中 when 表达式相比 Java 的 switch 有什么优势？

when 是 Kotlin 中用来替代 Java switch 的控制流语句，功能更强大、使用更灵活。

相比 Java 的 switch，when 的优势很明显。首先，when 是表达式，可以有返回值，能直接赋值给变量，而 Java 的 switch 是语句。其次，when 不需要 break，避免了忘记写 break 导致的 bug。第三，when 支持的条件类型更丰富，不只是常量，还可以是范围、类型判断、任意表达式。第四，when 可以不带参数，作为 if-else 的优雅替代。

// when 作为表达式，有返回值
val score = 85
val grade = when (score) {
    in 90..100 -> "优秀"
    in 80..89 -> "良好"
    in 60..79 -> "及格"
    else -> "不及格"
}

// 多个条件用逗号分隔
val dayOfWeek = 1
val dayType = when (dayOfWeek) {
    1, 2, 3, 4, 5 -> "工作日"
    6, 7 -> "周末"
    else -> "无效"
}

// 类型判断
fun describe(obj: Any) = when (obj) {
    is String -> "字符串，长度 ${obj.length}"
    is Int -> "整数"
    is List<*> -> "列表，大小 ${obj.size}"
    else -> "其他类型"
}

// 无参数的 when，替代 if-else
val x = 10
when {
    x > 0 -> println("正数")
    x < 0 -> println("负数")
    else -> println("零")
}

1. when 表达式必须穷尽所有情况

如果 when 用作表达式（有返回值），Kotlin 要求你必须覆盖所有可能的情况，否则编译不通过。这通常需要加一个 else 分支。这种强制要求能避免遗漏分支的 bug。如果 when 只是作为语句使用，则不强制要求 else。

2. 密封类和 when 的完美搭配

when 和密封类（sealed class）结合使用非常强大。密封类限定了子类的数量，编译器知道所有可能的类型，所以在 when 中处理密封类时，如果覆盖了所有子类，就不需要 else 分支。而且如果以后新增子类，编译器会提示你补充 when 分支，避免遗漏。

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handle(result: Result) = when (result) {
    is Result.Success -> println(result.data)
    is Result.Error -> println(result.message)
    Result.Loading -> println("加载中")
    // 不需要 else，因为已经覆盖了所有情况
}

3. when 的性能考虑

when 的底层实现会根据情况优化。如果分支较少，编译成 if-else 链。如果是整数等值判断且分支较多，会编译成 tableswitch 或 lookupswitch 指令，性能很好。所以不用担心 when 比 if-else 慢。

4. 实际开发中的使用场景

在 Android 开发中，when 的使用场景非常多。比如处理不同的点击事件、根据状态显示不同 UI、处理网络请求的不同结果等。when 的简洁性和表达力让代码更清晰。养成用 when 代替多个 if-else 的习惯，代码质量会提升一个档次。

Kotlin 的可见性修饰符有哪些？和 Java 有什么区别？

Kotlin 有四种可见性修饰符：private、protected、internal 和 public，默认是 public。虽然和 Java 看起来差不多，但实际含义有不少区别。

最大的区别是默认可见性。Java 默认是包级私有（package-private），Kotlin 默认是 public。这是因为 Kotlin 认为大部分情况下类和成员都应该是公开的，如果要限制访问，就显式声明 private。

另一个重要区别是 internal 修饰符。internal 表示在同一个模块（module）内可见，这是 Kotlin 特有的。Java 没有模块级的可见性控制，只能用包来控制，但包的控制力度不够。Kotlin 的 internal 很实用，特别是在多模块项目中。

protected 的含义也不同。在 Java 中，protected 成员在同包内也可见，但 Kotlin 的 protected 只在类及其子类中可见，更符合"保护"的语义。

// public：默认，任何地方可见
class PublicClass

// private：只在当前文件或类内可见
private class PrivateClass

// internal：同一模块内可见
internal class InternalClass

// protected：只能用在类成员上，子类可见
open class Parent {
    protected fun protectedMethod() {}
}

1. 顶层声明的可见性

Kotlin 允许在文件顶层定义类、函数、属性，它们也可以用可见性修饰符。顶层的 private 表示只在当前文件内可见，这在 Java 中是做不到的（Java 的顶层类只能是 public 或包级私有）。这个特性很适合把一些辅助函数和类限制在单个文件内。

// 只在当前文件内可见
private fun helperFunction() {}

// 同一模块内可见
internal fun moduleFunction() {}

2. 模块的概念

Kotlin 的模块指的是一起编译的一组文件，具体来说：一个 Gradle 模块、一个 Maven 项目、一个 IntelliJ IDEA 模块等。internal 修饰符让你能精确控制 API 的可见范围，既不像 public 那样完全开放，也不像 private 那样完全封闭。在开发 SDK 或库时，internal 特别有用，可以把内部实现细节隐藏起来。

3. 没有 package-private

Java 的默认可见性是包级私有，即同一个包内可见。Kotlin 认为这种设计不够好，因为包名是可以伪造的，任何人都可以创建同名包来访问你的代码。所以 Kotlin 去掉了包级私有，改用模块级的 internal。如果你真的需要包级私有的效果，可以用 internal 代替。

4. 实际开发中的建议

在实际开发中，遵循最小权限原则：默认用 private，只在需要时才放宽限制。类的内部实现细节都用 private，对外提供的 API 用 public，模块内部的工具类用 internal。这样能让代码结构更清晰，减少耦合。在团队协作中，清晰的可见性控制能避免别人误用你的内部实现。

Kotlin 的空安全是什么？如何实现的？

Kotlin 的空安全是它最重要的特性之一，目的是在编译期就消除空指针异常（NullPointerException）。在 Java 中，空指针异常是最常见的崩溃原因，被称为"十亿美元的错误"。Kotlin 从语言层面解决了这个问题。

Kotlin 的空安全实现方式是把类型分为可空类型和非空类型。默认情况下，所有类型都是非空的，不能赋值为 null。如果要允许 null，需要在类型后面加问号（?）。这样编译器就能在编译期检查，强制你处理可能为 null 的情况。

下面的例子展示了可空类型和非空类型的区别以及如何安全地处理：

// 非空类型，不能为 null
var name: String = "张三"
// name = null  // 编译错误

// 可空类型，可以为 null
var nullableName: String? = "李四"
nullableName = null  // OK

// 访问可空类型时，必须处理 null 的情况
// nullableName.length  // 编译错误
nullableName?.length  // 安全调用，如果为 null 返回 null

这种设计让空指针问题从运行时提前到编译期，在写代码的时候就能发现问题，而不是等到程序崩溃才知道。

1. 空安全的操作符

Kotlin 提供了几种处理可空类型的操作符。

• 安全调用操作符（?.）在对象为 null 时返回 null，而不是抛异常。
• Elvis 操作符（?:）用来提供默认值。
• 非空断言（!!）强制认为对象不为 null，但如果实际为 null 会抛异常，要慎用。

这三个操作符的使用示例：

val name: String? = null

// 安全调用
val length = name?.length  // 返回 null

// Elvis 操作符提供默认值
val length2 = name?.length ?: 0  // 返回 0

// 非空断言，慎用
// val length3 = name!!.length  // 会抛异常

2. 安全的类型转换

Kotlin 的类型转换也是安全的。as? 操作符在转换失败时返回 null，而不是抛 ClassCastException。这和空安全的设计思路一致，把运行时异常变成编译期检查。

val obj: Any = "Hello"
val str: String? = obj as? String  // 成功，str = "Hello"
val num: Int? = obj as? Int        // 失败，num = null

3. let 函数处理可空对象

let 是 Kotlin 的作用域函数，常用来处理可空对象。它只在对象不为 null 时执行代码块，在代码块内对象就是非空的，可以直接使用。

val name: String? = "张三"
name?.let {
    // 这里 it 是非空的 String
    println("姓名：$it")
    println("长度：${it.length}")
}

4. 空安全的实践价值

空安全不只是避免崩溃，更重要的是让代码意图更清晰。看到 String 类型，就知道它不可能为 null，不用担心空指针。看到 String? 类型，就知道要小心处理。这种明确性让代码更容易理解和维护。在团队协作中，API 的可空性一目了然，减少了沟通成本。虽然一开始可能觉得到处写问号很麻烦，但习惯之后会发现它带来的好处远大于不便。Google 的统计显示，使用 Kotlin 后，Android 应用的空指针崩溃率下降了 30% 以上。

空安全是 Kotlin 最具价值的特性之一，它从根本上改变了我们处理空值的方式。在面试中，能深入讲解空安全的实现机制和实践价值，会让面试官看到你不仅会用 Kotlin，更理解它的设计哲学。

Kotlin 中可空类型和非空类型有什么区别？

可空类型和非空类型是 Kotlin 类型系统的核心概念，区别在于能否赋值为 null。非空类型不能为 null，可空类型可以为 null，两者在语法上通过问号（?）来区分。

非空类型就是普通的类型声明，比如 String、Int、User 等，它们的值不能是 null。如果你尝试把 null 赋值给非空类型，编译器会直接报错。这保证了非空类型的变量一定有值，可以放心使用，不用担心空指针异常。

可空类型是在类型后面加问号，比如 String?、Int?、User? 等，它们的值可以是 null，也可以是正常的值。使用可空类型时，编译器会强制你进行空检查或使用安全调用，否则不让编译通过。

// 非空类型
var name: String = "张三"
name = "李四"  // OK
// name = null  // 编译错误

// 可空类型
var nullableName: String? = "王五"
nullableName = null  // OK

// 使用时的区别
println(name.length)  // 非空类型可以直接使用
// println(nullableName.length)  // 编译错误，必须处理 null
println(nullableName?.length)  // 安全调用，OK

这种设计让类型本身就带有"是否可为 null"的信息，编译器能在编译期保证安全性。

1. 如何选择可空还是非空

在实际开发中，优先使用非空类型。只有在值真的可能不存在时，才使用可空类型。比如用户的昵称可能没填，就用 String?。但用户的 ID 一定存在，就用 String。这种设计能让代码意图更明确，也能减少不必要的空检查。

2. 可空类型的继承关系

从类型关系上看，非空类型是可空类型的子类型。也就是说，非空类型可以赋值给可空类型，但反过来不行。这符合直觉：一个确定不为 null 的值当然可以用在可能为 null 的地方，但一个可能为 null 的值不能直接当作非空值使用。

val nonNull: String = "Hello"
val nullable: String? = nonNull  // OK

val nullable2: String? = null
// val nonNull2: String = nullable2  // 编译错误
val nonNull3: String = nullable2 ?: "默认值"  // OK，提供默认值

3. 平台类型的特殊情况

在 Kotlin 中调用 Java 代码时，会遇到平台类型（Platform Type）。因为 Java 没有可空性信息，Kotlin 不知道 Java 方法返回的值是否可为 null，就标记为平台类型（String!）。平台类型既可以当作可空类型，也可以当作非空类型使用，但这就失去了空安全保护，需要开发者自己小心。建议在调用 Java 代码时，手动标注可空性，避免问题。

4. 可空类型的泛型

泛型也支持可空性。

List<String> 是元素不可为 null 的列表， List<String?> 是元素可为 null 的列表。 List<String>? 是列表本身可为 null，但元素不可为 null。 List<String?>? 是列表和元素都可为 null。这种灵活性让你能精确表达意图。

val list1: List<String> = listOf("a", "b")  // 列表和元素都非空
val list2: List<String?> = listOf("a", null)  // 列表非空，元素可空
val list3: List<String>? = null  // 列表可空，元素非空
val list4: List<String?>? = null  // 都可空

Kotlin 中的安全调用操作符 ?. 和非空断言 !! 有什么区别？

安全调用操作符（?.）和非空断言（!!）都是用来处理可空类型的，但它们的行为和风险完全不同。

安全调用操作符（?.）是安全的做法。当对象为 null 时，整个表达式返回 null，不会抛异常。这是 Kotlin 推荐的处理可空类型的方式，把可能的问题在编译期就考虑到了。

非空断言（!!）是危险的做法。它告诉编译器"我确定这个值不为 null"，如果实际为 null，程序会抛出空指针异常。本质上就是强行把可空类型转成非空类型，放弃了 Kotlin 的空安全保护。

val name: String? = null

// 安全调用，返回 null
val length1 = name?.length
println(length1)  // 输出：null

// 非空断言，抛出异常
// val length2 = name!!.length  // 抛出 KotlinNullPointerException

// 链式安全调用
val user: User? = getUser()
val city = user?.address?.city  // 任何一个为 null，结果就是 null

在实际开发中，应该尽量避免使用 !!，优先使用 ?. 配合 ?: 提供默认值，或者用 if 判空，或者用 let 处理。只有在你百分百确定值不为 null 的极少数情况下，才考虑用 !!。

1. 何时可以使用非空断言

虽然不推荐用 !!，但确实有一些场景可以用。比如刚刚赋值后立即使用，在逻辑上不可能为 null。或者某些框架的限制，变量初始化时机晚于声明时机，但你知道使用时一定已经初始化了。但即使在这些场景，也建议先评估能否用其他方式避免，比如用 lateinit、懒加载等。

// 这种情况可以用 !!
val intent = Intent()
intent.putExtra("key", "value")
val value = intent.getStringExtra("key")!!  // 刚刚放进去，肯定不为 null

// 但更好的做法是提供默认值
val value2 = intent.getStringExtra("key") ?: "defaultValue"

2. 安全调用的链式操作

安全调用可以链式使用，这在处理复杂对象时特别有用。只要链条中任何一环为 null，整个表达式就返回 null，不会继续执行后面的调用。这比 Java 中层层判空优雅多了。

// Java 中需要层层判空
String city = null;
if (user != null) {
    if (user.getAddress() != null) {
        city = user.getAddress().getCity();
    }
}

// Kotlin 一行搞定
val city = user?.address?.city

3. let 函数更优雅地处理

在很多情况下，用 let 函数比单独的安全调用更清晰。let 会在对象不为 null 时执行代码块，在代码块内对象就是非空的，可以直接使用。

val name: String? = getName()

// 使用 ?.
name?.let {
    println("姓名：$it")
    println("长度：${it.length}")
    // 可以执行多个操作
}

// 相当于
if (name != null) {
    println("姓名：$name")
    println("长度：${name.length}")
}

4. !! 的代码审查红线

在很多 Kotlin 项目的代码规范中，!! 是代码审查的重点检查对象。有的团队甚至禁止使用 !!，或者要求每次使用都必须写注释说明理由。这是因为 !! 会把空安全的优势都放弃掉，重新回到 Java 那种随时可能空指针的状态。如果在面试中被问到这个问题，表达出"优先用 ?. 而不是 !!"的观点，能体现你对 Kotlin 理念的理解。

Kotlin 中的 Elvis 操作符 ?: 有什么作用？如何使用？

Elvis 操作符（?:）用来为可空类型提供默认值，它的名字来源于猫王（Elvis Presley）的发型，侧过来看 ?: 像个表情。

Elvis 操作符的作用很简单：如果左边的表达式不为 null，就返回左边的值。如果左边为 null，就返回右边的值。这是一种简洁的三元表达式，专门用来处理 null 值的场景。

val name: String? = null
val displayName = name ?: "匿名用户"
println(displayName)  // 输出：匿名用户

// 相当于
val displayName2 = if (name != null) name else "匿名用户"

// 和安全调用配合使用
val length = name?.length ?: 0  // 如果 name 为 null，length 为 0

// 链式使用
val result = value1 ?: value2 ?: value3 ?: "默认值"

Elvis 操作符在实际开发中非常常用，特别是在处理可选参数、提供默认配置、处理 API 返回值等场景。它让代码更简洁、更易读。

1. Elvis 操作符的高级用法

Elvis 操作符的右边不只可以是值，还可以是表达式，包括 return、throw 等。这在参数校验和早返回场景特别有用。

▼kotlin

复制代码fun processUser(user: User?) {
    val validUser = user ?: return  // 如果为 null，直接返回
    // 这里 validUser 是非空的
    println(validUser.name)
}

fun login(username: String?) {
    val name = username ?: throw IllegalArgumentException("用户名不能为空")
    // 这里 name 是非空的
    performLogin(name)
}

2. 和安全调用的完美搭配

Elvis 操作符经常和安全调用（?.）一起使用，这是处理可空类型的标准组合。安全调用保证不会抛异常，Elvis 操作符提供默认值，两者结合能优雅地处理各种空值场景。

// 获取用户城市，如果任何环节为 null，返回"未知"
val city = user?.address?.city ?: "未知"

// 获取列表第一个元素，如果列表为空或为 null，返回默认值
val first = list?.firstOrNull() ?: "默认值"

// 计算字符串长度，null 时返回 0
val length = text?.length ?: 0

3. 对比三元运算符

很多语言有三元运算符（condition ? value1 : value2），但 Kotlin 没有。一方面是因为 Kotlin 的 if 是表达式，可以直接返回值，不需要三元运算符。另一方面，Elvis 操作符在处理 null 值时比三元运算符更简洁。

// Kotlin 的 if 表达式
val max = if (a > b) a else b

// Elvis 操作符处理 null
val value = nullableValue ?: defaultValue

// 如果用 if 写，就啰嗦了
val value2 = if (nullableValue != null) nullableValue else defaultValue

4. 实际开发中的应用场景

在 Android 开发中，Elvis 操作符的应用场景非常多。比如从 Intent 获取参数时提供默认值、从 Bundle 获取数据时的兜底、SharedPreferences 读取配置时的默认值、网络请求失败时的默认数据等。养成用 Elvis 操作符的习惯，能让代码更健壮，减少因为 null 值导致的异常行为。

// 从 Intent 获取参数
val userId = intent.getStringExtra("userId") ?: "default_id"

// 从配置读取值
val timeout = config.timeout ?: 30000

// API 返回值处理
val data = response.body()?.data ?: emptyList()

如何在 Kotlin 中处理 Java 代码的空安全问题？

在 Kotlin 中调用 Java 代码时，空安全是一个需要特别注意的问题。因为 Java 没有可空性类型系统，Kotlin 无法确定 Java 方法返回的值是否可能为 null，这时会引入平台类型（Platform Type）的概念。

平台类型在 Kotlin 中用感叹号表示（String!），表示这个类型的可空性未知。你可以把它当作可空类型（String?）使用，也可以当作非空类型（String）使用。Kotlin 不会强制你做空检查，但这意味着你要自己承担空指针的风险。

// Java 代码
public class JavaClass {
    public String getName() {
        return null;  // 可能返回 null
    }
}

// Kotlin 调用
val javaObj = JavaClass()
val name = javaObj.name  // name 的类型是 String!（平台类型）

// 如果直接使用，可能出问题
// val length = name.length  // 如果 name 为 null，抛异常

// 安全的做法
val length = name?.length ?: 0  // 当作可空类型处理

最佳实践是在调用 Java 代码时，主动标注可空性，或者用安全调用处理。如果你维护 Java 代码，建议加上 @Nullable 和 @NonNull 注解，Kotlin 能识别这些注解，提供更好的空安全检查。

1. Java 注解和 Kotlin 的互操作

Java 有多种空值注解，如 @Nullable、@NonNull（来自不同的库，如 JetBrains、Android、JSR-305 等）。Kotlin 能识别这些注解，并据此推断类型的可空性。如果 Java 方法标注了 @NonNull，Kotlin 会把返回值当作非空类型。如果标注了 @Nullable，会当作可空类型。如果没有注解，就是平台类型。

// Java 代码
public class JavaUser {
    @Nullable
    public String getNickname() {
        return nickname;
    }
    
    @NonNull
    public String getId() {
        return id;
    }
}

// Kotlin 调用
val user = JavaUser()
val nickname: String? = user.nickname  // 可空类型
val id: String = user.id  // 非空类型

2. 如何处理平台类型

遇到平台类型时，有几种处理策略。保守策略是把所有平台类型都当作可空类型处理，用安全调用和 Elvis 操作符。激进策略是如果你确定不会为 null，就当作非空类型使用。折中策略是根据 API 文档和经验判断，该判空的判空，不需要的直接用。实际开发中建议偏保守，毕竟崩溃的代价很高。

3. 混合项目的最佳实践

在 Kotlin 和 Java 混合的项目中，建议逐步给 Java 代码加上空值注解。可以用静态分析工具（如 Android Studio 的 Infer Nullity）自动推断并添加注解。对于新写的 Java 代码，强制要求加注解。对于频繁调用的 Java API，优先加注解。这样能让 Kotlin 代码有更好的空安全保障。

4. 迁移策略

很多团队在从 Java 迁移到 Kotlin 时，采用渐进式策略。不是一次性重写所有代码，而是新功能用 Kotlin 写，老代码逐步改造。在这个过程中，Java 代码的空安全处理很关键。建议制定规范：所有被 Kotlin 调用的 Java API 都必须标注可空性，或者在 Kotlin 端做显式的空检查。这样能减少迁移过程中的问题。

Kotlin 中的 object 关键字有哪些用法？

object 关键字在 Kotlin 中有三种用法：对象声明（单例）、对象表达式（匿名对象）和伴生对象（companion object）。

对象声明用来创建单例模式，不需要手写单例代码，编译器会保证线程安全和懒加载。直接用 object 声明一个类，它就自动成为单例，整个应用只有一个实例。

// 对象声明：单例模式
object DatabaseManager {
    init {
        println("初始化数据库")
    }
    
    fun query(sql: String) {
        println("执行查询：$sql")
    }
}

// 使用单例
DatabaseManager.query("SELECT * FROM users")

对象表达式类似 Java 的匿名内部类，用来创建临时的匿名对象，常用于实现接口或继承类。

// 对象表达式：匿名对象
val clickListener = object : View.OnClickListener {
    override fun onClick(v: View?) {
        println("点击了")
    }
}

// 或者不继承任何类
val obj = object {
    val x = 10
    val y = 20
}
println(obj.x + obj.y)

伴生对象用来定义类的"静态"成员，类似 Java 的 static，但更灵活。

// 伴生对象：类似静态成员
class User(val name: String) {
    companion object {
        const val MAX_AGE = 150
        
        fun create(name: String): User {
            return User(name)
        }
    }
}

// 使用
val user = User.create("张三")
println(User.MAX_AGE)

1. 对象声明的线程安全

Kotlin 的对象声明是线程安全的单例实现，等价于 Java 的静态内部类单例模式。它是懒加载的，只有第一次访问时才会初始化。而且初始化过程由 JVM 保证线程安全，不需要额外的同步代码。这比手写 Java 单例简洁很多。

// Kotlin 一行
object Singleton

// 相当于 Java 的静态内部类单例
public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

2. 对象表达式的闭包特性

对象表达式可以访问外部作用域的变量，形成闭包。这在事件监听、回调等场景很有用。和 Java 不同，Kotlin 的对象表达式可以修改捕获的变量，不需要变量是 final 的。

fun setupButton() {
    var clickCount = 0
    
    button.setOnClickListener(object : View.OnClickListener {
        override fun onClick(v: View?) {
            clickCount++  // 可以修改外部变量
            println("点击次数：$clickCount")
        }
    })
}

3. 伴生对象的高级用法

伴生对象可以有名字，可以实现接口，甚至可以有扩展函数。这让它比 Java 的 static 更灵活。常用的工厂方法模式、常量定义都可以用伴生对象实现。

class User private constructor(val name: String, val age: Int) {
    companion object Factory {
        fun create(name: String, age: Int): User? {
            return if (age in 0..150) User(name, age) else null
        }
    }
}

// 可以省略伴生对象的名字
val user = User.create("张三", 25)

// 也可以用名字访问
val user2 = User.Factory.create("李四", 30)

4. 何时使用哪种 object

对象声明适合全局单例，如工具类、管理器、配置类。对象表达式适合一次性的匿名对象，如事件监听、简单回调。伴生对象适合类的静态成员，如工厂方法、常量、静态工具方法。在 Android 开发中，对象声明常用于管理类（如网络管理、数据库管理），伴生对象常用于创建对象和定义常量。

Kotlin 的类默认是 final 的，为什么这样设计？

Kotlin 中的类默认是 final 的，不能被继承。如果要允许继承，需要显式用 open 关键字标记。方法和属性也是一样，默认 final，需要继承时用 open 标记。这个设计和 Java 完全相反，Java 的类默认可继承，需要 final 才能禁止继承。

// 默认是 final 的，不能被继承
class User

// 需要 open 才能被继承
open class Animal {
    open fun makeSound() {  // 方法也需要 open
        println("动物叫")
    }
}

class Dog : Animal() {
    override fun makeSound() {  // override 隐含了 open
        println("汪汪")
    }
}

这样设计的原因是基于"组合优于继承"的设计原则。继承会带来强耦合，子类依赖父类的实现细节，父类的修改可能破坏子类。而且继承容易被滥用，很多场景用组合更合适。Kotlin 要求显式声明 open，就是让你仔细思考这个类是否真的需要被继承，避免无意中创建脆弱的继承层次。

另一个原因是性能优化。final 类和方法可以被编译器内联优化，方法调用更快。JVM 对 final 类也能做更多的优化。默认 final 让性能优化成为默认行为，而不是需要特殊处理的情况。

1. Effective Java 的建议

这个设计理念来自 Joshua Bloch 的《Effective Java》，书中明确建议"为继承而设计并提供文档说明，否则就禁止继承"。很多 Java 代码因为随意继承导致问题，父类的一个小改动就可能破坏子类。Kotlin 从语言层面强制这个最佳实践，让你必须有意识地设计继承体系。

2. open、abstract、override 的关系

open 表示可以被继承或重写。abstract 表示抽象的，必须被继承和实现，隐含了 open。override 表示重写父类方法，重写后的方法默认也是 open 的，可以被进一步重写。如果不想让子类再重写，可以用 final override。

abstract class Animal {
    abstract fun eat()  // 抽象方法隐含 open
    open fun sleep() {}  // 普通方法需要显式 open
}

open class Dog : Animal() {
    override fun eat() {}  // override 的方法默认 open
    
    final override fun sleep() {}  // 不允许再被重写
}

3. 何时使用继承

虽然 Kotlin 鼓励组合，但继承也有适用场景。抽象类定义模板方法模式、密封类限定类型层次、接口定义契约等，都是合理的继承使用。关键是要有意识地设计，明确类的继承契约，提供清晰的文档。在 Android 开发中，继承 Activity、Fragment、ViewModel 等框架类是必需的，这些类本身就设计为可继承的。

4. 组合优于继承的实践

在实际开发中，很多场景用组合比继承更好。比如给类添加功能，用扩展函数而不是继承。需要共享行为，用接口加委托而不是继承。需要复用代码，抽取工具类而不是继承。Kotlin 提供了委托（by）关键字，让组合模式更容易实现。

// 用委托代替继承
interface Base {
    fun print()
}

class BaseImpl : Base {
    override fun print() = println("BaseImpl")
}

// 通过委托复用 BaseImpl 的实现
class Derived(b: Base) : Base by b

// 使用
val base = BaseImpl()
val derived = Derived(base)
derived.print()  // 调用 BaseImpl 的实现

Kotlin 中的委托是什么？有哪些应用场景？

委托是一种设计模式，Kotlin 在语言层面提供了对委托的支持，分为类委托和属性委托两种。

类委托让一个类可以把接口的实现委托给另一个对象，使用 by 关键字。这样可以复用代码，同时避免继承带来的问题。

interface Base {
    fun print()
    fun printWithPrefix(prefix: String)
}

class BaseImpl : Base {
    override fun print() = println("BaseImpl")
    override fun printWithPrefix(prefix: String) = println("$prefix: BaseImpl")
}

// 类委托：把 Base 的实现委托给 b
class Derived(b: Base) : Base by b {
    // 可以选择性地重写某些方法
    override fun printWithPrefix(prefix: String) {
        println("Derived: $prefix")
    }
}

// 使用
val base = BaseImpl()
val derived = Derived(base)
derived.print()  // 调用 BaseImpl 的实现
derived.printWithPrefix("Test")  // 调用 Derived 的重写

属性委托让属性的 get 和 set 逻辑委托给另一个对象，也用 by 关键字。Kotlin 标准库提供了几个常用的委托：lazy（懒加载）、observable（观察者）、vetoable（可否决）等。

// lazy 延迟初始化
val lazyValue: String by lazy {
    println("初始化")
    "Hello"
}
println(lazyValue)  // 第一次访问时初始化
println(lazyValue)  // 第二次直接返回

// observable 观察属性变化
var name: String by Delegates.observable("初始值") { prop, old, new ->
    println("${prop.name} 从 $old 变为 $new")
}
name = "张三"  // 触发观察者

1. 类委托的优势

类委托是"组合优于继承"的具体实现。你可以复用其他类的实现，而不需要继承它们。这避免了继承带来的强耦合和脆弱基类问题。而且可以同时委托多个接口，这是多继承做不到的。

interface Flyable {
    fun fly()
}

interface Swimmable {
    fun swim()
}

class Bird : Flyable {
    override fun fly() = println("飞翔")
}

class Fish : Swimmable {
    override fun swim() = println("游泳")
}

// 同时委托两个接口
class SuperAnimal(f: Flyable, s: Swimmable) : Flyable by f, Swimmable by s

val animal = SuperAnimal(Bird(), Fish())
animal.fly()   // 委托给 Bird
animal.swim()  // 委托给 Fish

2. lazy 委托的懒加载

lazy 是最常用的属性委托，实现线程安全的懒加载。属性在第一次被访问时才初始化，之后直接返回缓存的值。这在初始化开销大、可能用不到的属性时很有用。

class User {
    // 线程安全的懒加载
    val expensiveData: String by lazy {
        println("初始化昂贵的数据")
        fetchFromNetwork()
    }
    
    // 不同的线程安全模式
    val data1: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { "线程安全" }
    val data2: String by lazy(LazyThreadSafetyMode.NONE) { "不考虑线程安全" }
}

3. observable 和 vetoable 委托

observable 可以监听属性的变化，在属性赋值后执行回调。vetoable 可以在赋值前判断是否允许修改。这两个委托在数据绑定、表单验证等场景很有用。

class User {
    // 观察属性变化
    var age: Int by Delegates.observable(0) { prop, old, new ->
        println("年龄从 $old 变为 $new")
    }
    
    // 否决不合法的值
    var score: Int by Delegates.vetoable(0) { prop, old, new ->
        new in 0..100  // 只接受 0-100 的值
    }
}

val user = User()
user.age = 25    // 输出：年龄从 0 变为 25
user.score = 90  // OK
user.score = 150 // 被否决，保持 90

4. 自定义属性委托

可以自己实现属性委托，只需要提供 getValue 和 setValue 方法。这在封装复杂的属性逻辑、实现自定义缓存、日志记录等场景很有用。

class Preference<T>(private val key: String, private val default: T) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return getFromSharedPreferences(key, default)
    }
    
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        saveToSharedPreferences(key, value)
    }
}

// 使用自定义委托
class Settings {
    var username: String by Preference("username", "")
    var darkMode: Boolean by Preference("dark_mode", false)
}

在 Android 开发中，委托的应用场景非常多。ViewBinding 的委托、ViewModel 的委托、SharedPreferences 的委托、Lifecycle 观察者等，都是委托模式的应用。掌握委托能让代码更简洁、更易维护。

Kotlin 中的 by lazy 延迟初始化是如何工作的？

by lazy 是 Kotlin 提供的属性委托，用于实现线程安全的延迟初始化。属性在第一次被访问时才执行初始化代码，之后直接返回缓存的值，不会重复初始化。

class Example {
    // 延迟初始化属性
    val lazyValue: String by lazy {
        println("初始化中...")
        "Hello World"  // 初始化代码
    }
}

val example = Example()
println("创建对象")
// 此时还没有初始化 lazyValue

println(example.lazyValue)  // 第一次访问，执行初始化
// 输出：初始化中...
// 输出：Hello World

println(example.lazyValue)  // 第二次访问，直接返回缓存值
// 输出：Hello World（不会再输出"初始化中..."）

by lazy 的工作原理是基于双重检查锁定（Double-Check Locking）。第一次访问时，会获取锁并执行初始化代码，把结果缓存起来。后续访问直接返回缓存值，不需要加锁。这保证了线程安全和性能。

by lazy 只能用于 val 属性，不能用于 var，因为延迟初始化的值应该是不可变的。这也符合函数式编程的思想。

1. lazy 的线程安全模式

lazy 函数接受一个可选的 LazyThreadSafetyMode 参数，控制线程安全行为。有三种模式：SYNCHRONIZED（默认，线程安全）、PUBLICATION（允许多个线程同时初始化，但只有一个结果被使用）、NONE（不考虑线程安全，单线程场景）。

// 默认：线程安全，使用双重检查锁
val safe: String by lazy { "线程安全" }

// 等价于
val safe2: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { "线程安全" }

// 不考虑线程安全，性能更好
val unsafe: String by lazy(LazyThreadSafetyMode.NONE) { "不安全" }

// 允许多个线程初始化，但只使用第一个完成的结果
val publication: String by lazy(LazyThreadSafetyMode.PUBLICATION) { "发布模式" }

2. lazy 和 lateinit 的区别

lazy 和 lateinit 都用于延迟初始化，但有很大区别。lazy 用于 val 属性，只能初始化一次，自动线程安全。lateinit 用于 var 属性，可以多次赋值，没有线程安全保证，而且只能用于非空类型。选择哪个取决于具体需求。

class Example {
    // lazy：val，自动初始化，线程安全
    val lazyValue: String by lazy {
        computeValue()
    }
    
    // lateinit：var，手动初始化，需要自己保证
    lateinit var lateinitValue: String
    
    fun init() {
        lateinitValue = "初始化"
    }
}

3. lazy 的性能考虑

虽然 lazy 默认是线程安全的，但线程安全是有开销的。在确定单线程场景下，可以用 NONE 模式提升性能。在大量属性都用 lazy 的情况下，这个优化能带来明显的收益。

class Config {
    // 配置类通常在单线程中使用，可以用 NONE 模式
    val option1: String by lazy(LazyThreadSafetyMode.NONE) { loadOption1() }
    val option2: String by lazy(LazyThreadSafetyMode.NONE) { loadOption2() }
    val option3: String by lazy(LazyThreadSafetyMode.NONE) { loadOption3() }
}

4. lazy 的实际应用场景

lazy 在实际开发中应用广泛。初始化开销大的对象（如数据库连接、网络客户端）、可能用不到的资源、需要在初始化时访问其他属性的对象，都适合用 lazy。在 Android 开发中，Fragment 的 arguments 解析、ViewModel 的懒加载、单例的实现等，都常用 lazy。

// Fragment 参数解析
class UserFragment : Fragment() {
    private val userId: String by lazy {
        arguments?.getString("user_id") ?: ""
    }
}

// ViewModel 懒加载
class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by lazy {
        ViewModelProvider(this).get(MyViewModel::class.java)
    }
}

// 单例实现
class DatabaseManager private constructor() {
    companion object {
        val instance: DatabaseManager by lazy {
            DatabaseManager()
        }
    }
}

Kotlin 的泛型和 Java 泛型有什么区别？型变是什么？

Kotlin 的泛型在语法和功能上和 Java 类似，但提供了更强大的型变（Variance）支持，让泛型使用更安全、更灵活。

最大的区别是 Kotlin 支持声明处型变（Declaration-site Variance），可以在定义类时就指定型变规则，用 out 和 in 关键字。Java 只支持使用处型变（Use-site Variance），需要在使用泛型时每次都指定通配符（? extends 和 ? super）。

// Kotlin 声明处型变：生产者用 out（协变）
interface Producer<out T> {
    fun produce(): T
}

// 消费者用 in（逆变）
interface Consumer<in T> {
    fun consume(item: T)
}

// 使用时不需要额外声明
val producer: Producer<String> = object : Producer<String> {
    override fun produce() = "Hello"
}
val anyProducer: Producer<Any> = producer  // OK，协变

// Java 需要在使用时指定
// Producer<? extends String> producer = ...

型变描述的是类型参数之间的继承关系。协变（out）表示如果 A 是 B 的子类型，那么 Producer 是 Producer 的子类型。逆变（in）表示如果 A 是 B 的子类型，那么 Consumer 是 Consumer 的子类型。不变（invariant）表示 Container 和 Container 没有继承关系。

1. 协变和逆变的记忆方法

   记住 生产者 out，消费者 in（PECS：Producer Extends, Consumer Super）。如果泛型类只生产 T 类型的值（作为返回值），用 out，表示协变。如果只消费 T 类型的值（作为参数），用 in，表示逆变。如果既生产又消费，只能不变。

// 只生产（返回 T），用 out
interface Source<out T> {
    fun nextItem(): T
}

// 只消费（接收 T），用 in
interface Sink<in T> {
    fun consume(item: T)
}

// 既生产又消费，不能用 out 或 in
interface Container<T> {
    fun get(): T
    fun set(item: T)
}

2. Kotlin 标准库中的型变

   Kotlin 标准库大量使用型变。List 是协变的（List<out E>），因为它是只读的，只能获取元素不能添加。MutableList 是不变的，因为可以读写。这种设计让集合使用更安全。

// List 是协变的
val strings: List<String> = listOf("a", "b")
val objects: List<Any> = strings  // OK

// MutableList 是不变的
val mutableStrings: MutableList<String> = mutableListOf("a", "b")
// val mutableObjects: MutableList<Any> = mutableStrings  // 编译错误

3. 使用处型变

   虽然 Kotlin 支持声明处型变，但有时还需要使用处型变。当一个不变的类在某个具体场景只用于生产或消费时，可以在使用时加 out 或 in。这类似 Java 的通配符。

// Array 是不变的
fun copy(from: Array<out Any>, to: Array<Any>) {
    // from 声明为 out，只能读取
    for (i in from.indices) {
        to[i] = from[i]
    }
}

// 使用
val ints: Array<Int> = arrayOf(1, 2, 3)
val anys: Array<Any> = Array(3) { "" }
copy(ints, anys)  // OK

4. 星投影

Kotlin 的星投影（Star Projection）对应 Java 的原始类型或无界通配符。Array<\*> 相当于 Array<out Any?>，表示"某种类型的数组，但不知道具体是什么"。星投影在不关心具体类型时很有用。

// 星投影
fun printArray(array: Array<*>) {
    for (item in array) {
        println(item)  // item 的类型是 Any?
    }
}

printArray(arrayOf(1, 2, 3))
printArray(arrayOf("a", "b", "c"))

型变是 Kotlin 泛型的高级特性，理解起来有难度，但掌握后能写出更安全、更灵活的代码。在面试中，能说出协变和逆变的区别、PECS 原则，就能展现对 Kotlin 泛型的深入理解。

函数

你想全面了解 Kotlin 中所有核心函数类型（包括中缀函数、扩展函数、内联函数、高阶函数等）的定义、核心特征、使用场景和具体示例，我会按照「类型定义→核心特征→使用场景→代码示例→注意事项」的结构，系统梳理 Kotlin 的所有函数类型，帮你彻底区分和掌握：

Kotlin 核心函数类型全览

Kotlin 的函数类型可从不同维度划分，核心类型包括：

1. 按「调用语法」：中缀函数（Infix Function）
2. 按「归属 / 扩展能力」：扩展函数（Extension Function）、成员函数、顶层函数
3. 按「编译方式」：内联函数（Inline Function）、非内联函数
4. 按「参数 / 返回值」：高阶函数（Higher-Order Function）、普通函数
5. 按「执行特性」：挂起函数（Suspend Function）、普通函数
6. 按「可见性 / 作用域」：局部函数、成员函数、顶层函数
7. 其他特殊函数：操作符重载函数、尾递归函数

核心函数类型速查表

核心使用原则

1. 需简化二元关系调用→中缀函数；
2. 需扩展已有类功能→扩展函数；
3. 需优化高阶函数性能→内联函数；
4. 需函数作为参数 / 返回值→高阶函数；
5. 需异步非阻塞操作→挂起函数；
6. 需递归优化→尾递归函数；
7. 需自定义运算符→操作符重载函数。

下面逐个详解，每个类型都包含「核心定义 + 关键特征 + 使用场景 + 可运行示例」：

1. 中缀函数（Infix Function）

核心定义

用infix关键字修饰的函数，支持「省略点号和括号」的中缀调用语法（a func b），本质是一种语法糖。

关键特征

• 必须是成员函数或扩展函数（不能是顶层函数）；
• 必须只有一个参数，且参数不能有默认值；
• 调用时可省略点号和括号，用空格分隔调用者和参数，代码更简洁直观。

使用场景

适合表达「二元关系」的操作（如关联、匹配、运算、判断等），让代码更接近自然语言。

示例

// 示例1：扩展函数实现中缀函数（判断字符串是否以指定后缀结尾）
infix fun String.endsWithSuffix(suffix: String): Boolean {
    return this.endsWith(suffix)
}

// 示例2：成员函数实现中缀函数（自定义计算器加法）
class Calculator(val base: Int) {
    infix fun add(num: Int): Int {
        return base + num
    }
}

// 使用
fun main() {
    // 中缀调用扩展函数
    val str = "HelloKotlin"
    println(str endsWithSuffix "Kotlin") // true（等价于str.endsWithSuffix("Kotlin")）
    
    // 中缀调用成员函数
    val calc = Calculator(10)
    println(calc add 20) // 30（等价于calc.add(20)）
}

注意事项

• 中缀函数的优先级低于算术运算符、逻辑运算符，高于赋值运算符；
• 避免滥用，仅在能提升代码可读性的二元关系场景使用。

2. 扩展函数（Extension Function）

核心定义

在不修改原有类源码的前提下，为该类添加新的成员函数，本质是静态方法的语法糖（JVM 层面）。

关键特征

• 语法：fun 接收者类型.函数名(参数): 返回值 { ... }；
• 可访问接收者的公有成员（属性 / 方法），但不能访问私有 / 保护成员；
• 扩展函数不会真正修改原有类，仅在编译期将接收者作为第一个参数传入函数。

使用场景

• 为第三方类（如 Java 的 String、List，Android 的 Context）添加便捷方法；
• 避免创建大量工具类（如StringUtils），让方法调用更符合面向对象风格；
• 拆分复杂类的方法，提升代码可读性。

示例

// 示例1：为String扩展空值判断方法
fun String?.isNullOrEmptyOrBlank(): Boolean {
    return this == null || this.isEmpty() || this.isBlank()
}

// 示例2：为List<Int>扩展求和方法
fun List<Int>.sum(): Int {
    var total = 0
    this.forEach { total += it }
    return total
}

// 使用
fun main() {
    println("".isNullOrEmptyOrBlank()) // true
    println(null.isNullOrEmptyOrBlank()) // true
    
    val list = listOf(1, 2, 3, 4)
    println(list.sum()) // 10
}

注意事项

• 扩展函数若与原有类的成员函数重名，调用时优先执行成员函数；
• 扩展属性需手动实现 getter/setter（无法直接添加字段）。

3. 内联函数（Inline Function）

核心定义

用inline关键字修饰的函数，编译器会将函数体直接「内联」到调用处（替换函数调用代码），而非创建函数调用栈，减少运行时开销。

关键特征

• 主要用于优化「参数包含函数类型」的函数（如高阶函数），避免创建匿名类 / 闭包对象；
• noinline：标记函数类型参数不内联；
• crossinline：标记内联的函数类型参数可被跨作用域调用（如协程、回调）。

使用场景

• 高阶函数（如let、run、with等作用域函数），减少闭包创建的性能损耗；
• 频繁调用的小函数，消除函数调用的栈开销；
• 需控制函数类型参数作用域的场景（crossinline）。

示例

// 示例1：基础内联函数（优化高阶函数）
inline fun withLock(lock: Any, action: () -> Unit) {
    synchronized(lock) {
        action()
    }
}

// 示例2：noinline + crossinline
inline fun testInline(
    inlineAction: () -> Unit,
    noinline noInlineAction: () -> Unit,
    crossinline crossInlineAction: () -> Unit
) {
    inlineAction() // 内联执行
    val thread = Thread(noInlineAction) // 非内联参数可作为函数参数传递
    thread.start()
    
    // crossinline参数可在协程/回调中调用
    kotlinx.coroutines.runBlocking {
        crossInlineAction()
    }
}

// 使用
fun main() {
    val lock = Any()
    withLock(lock) {
        println("执行加锁操作") // 代码会被内联到withLock的调用处
    }
}

注意事项

• 避免内联大函数（会导致字节码膨胀）；
• 内联函数不能是局部函数、open 函数、抽象函数。

4. 高阶函数（Higher-Order Function）

核心定义

满足以下任一条件的函数：

1. 接收一个或多个函数类型作为参数；
2. 返回值类型是函数类型。

关键特征

• 函数类型语法：(参数列表) -> 返回值（如(Int, Int) -> Int、() -> Unit）；
• 支持函数引用（::函数名）、lambda 表达式、匿名函数作为参数 / 返回值；
• 结合内联函数使用可避免性能损耗。

使用场景

• 提取通用逻辑，注入可变部分（如calculate函数，注入加减乘除逻辑）；
• 函数式编程（如集合的map、filter、reduce）；
• 回调函数（替代 Java 的匿名内部类）；
• 返回函数类型实现 “函数工厂”（如创建不同的计算器函数）。

示例

// 示例1：接收函数类型参数（通用计算逻辑）
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 示例2：返回函数类型（函数工厂）
fun createOperator(operator: String): (Int, Int) -> Int {
    return when (operator) {
        "+" -> { a, b -> a + b }
        "*" -> { a, b -> a * b }
        else -> { _, _ -> 0 }
    }
}

// 使用
fun main() {
    // 传入lambda作为参数
    val sum = calculate(10, 20) { a, b -> a + b }
    val mul = calculate(10, 20) { a, b -> a * b }
    println(sum) // 30
    println(mul) // 200
    
    // 调用返回的函数
    val addFunc = createOperator("+")
    println(addFunc(5, 5)) // 10
}

注意事项

• 非内联的高阶函数会创建闭包对象，可能导致额外的内存开销；
• 函数类型参数默认是final，不能在内部修改外部变量（除非用var或mutable类型）。

5. 挂起函数（Suspend Function）

核心定义

用suspend关键字修饰的函数，可在协程中暂停执行（不阻塞线程），等待结果后恢复执行，是 Kotlin 协程的核心。

关键特征

• 只能在协程或其他挂起函数中调用；
• 编译期会被转换为带有续体（Continuation）的普通函数；
• 支持delay()、await()等挂起操作，替代阻塞式的Thread.sleep()。

使用场景

• 异步操作（网络请求、数据库操作、文件读写）；
• 协程中的耗时操作（非阻塞式等待）；
• 与 Flow、StateFlow 等协程数据流配合使用。

示例

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

// 挂起函数：模拟网络请求
suspend fun fetchData(): String {
    delay(1000) // 非阻塞式延迟（替代Thread.sleep）
    return "模拟网络请求返回的数据"
}

// 挂起函数调用另一个挂起函数
suspend fun processData(): String {
    val data = fetchData()
    return "处理后的数据：$data"
}

// 使用（必须在协程中调用）
fun main() = runBlocking {
    val result = processData()
    println(result) // 处理后的数据：模拟网络请求返回的数据
}

注意事项

• 挂起函数不会自动创建协程，需在launch/async/runBlocking等协程作用域中调用；
• 挂起函数的异常可通过try-catch捕获，或通过CoroutineExceptionHandler处理。

6. 其他核心函数类型

6.1 成员函数 vs 顶层函数

示例：

// 顶层函数（直接定义在文件中）
fun printHello() {
    println("Hello 顶层函数")
}

class User {
    // 成员函数
    fun sayHello() {
        println("Hello 成员函数")
    }
}

fun main() {
    printHello() // 直接调用顶层函数
    User().sayHello() // 通过类实例调用成员函数
}

6.2 局部函数

• 核心定义：定义在其他函数内部的函数；

• 使用场景：封装函数内部的重复逻辑，避免暴露给外部；

• 示例：

  fun calculateTotal(prices: List<Double>): Double {
      // 局部函数：仅在calculateTotal内部可用
      fun validatePrice(price: Double): Boolean {
          return price >= 0
      }
      
      var total = 0.0
      prices.forEach {
          if (validatePrice(it)) {
              total += it
          }
      }
      return total
  }
  
  fun main() {
      println(calculateTotal(listOf(10.0, 20.0, -5.0))) // 30.0
  }
  

6.3 操作符重载函数

• 核心定义：用operator关键字修饰，重载 Kotlin 的操作符（如+、-、*、[]等）；

• 使用场景：让自定义类支持运算符操作，代码更简洁；

• 示例：

  data class Point(val x: Int, val y: Int) {
      // 重载+运算符
      operator fun plus(other: Point): Point {
          return Point(x + other.x, y + other.y)
      }
  }
  
  fun main() {
      val p1 = Point(1, 2)
      val p2 = Point(3, 4)
      val p3 = p1 + p2 // 等价于p1.plus(p2)
      println(p3) // Point(x=4, y=6)
  }
  

6.4 尾递归函数

• 核心定义：用tailrec关键字修饰，满足「尾递归」条件的函数（函数最后一步是调用自身），编译器会将其优化为循环，避免栈溢出；

• 使用场景：递归深度大的场景（如阶乘、斐波那契数列、树形遍历）；

• 示例：

  // 尾递归阶乘（避免栈溢出）
  tailrec fun factorial(n: Int, accumulator: Int = 1): Int {
      if (n <= 1) return accumulator
      return factorial(n - 1, n * accumulator) // 最后一步是调用自身
  }
  
  fun main() {
      println(factorial(5)) // 120
  }
  

成员函数

类成员函数（也叫类的成员方法），是定义在类（或接口、数据类等）内部，并且属于该类实例（或类本身）的函数。它是类的重要组成部分，和类的属性（成员变量）一起，共同构成了类的行为和状态，用于实现该类的具体功能。

简单来说：类就像一个 “模板”，成员函数就是这个模板赋予其实例的 “行为能力”。

类成员函数的两种常见类型

1. 实例成员函数（最常用）
2. 伴生对象成员函数（类级别的成员函数）

1. 实例成员函数（最常用）

就是上面示例中的setAge()、getPersonInfo()，也是默认的类成员函数类型：

• 依赖类的实例存在，必须先val/var 实例名 = 类名()创建对象，才能调用；
• 可以访问实例的所有成员属性（每个实例的属性值独立，函数调用结果可能因实例不同而不同）。

2. 伴生对象成员函数（类级别的成员函数）

如果想让类成员函数不依赖实例，直接通过「类名。函数名」调用（类似 Java 的static方法），可以使用companion object（伴生对象）内部的成员函数：

class Student {
    var studentId: String = ""
    var className: String = ""

    // 伴生对象：属于类本身，而非实例
    companion object {
        // 伴生对象中的成员函数（类级别的成员函数）
        fun createDefaultStudent(): Student {
            val student = Student()
            student.studentId = "S001"
            student.className = "一年级一班"
            return student
        }
    }
}

fun main() {
    // 无需创建 Student 实例，直接通过「类名.函数名」调用伴生对象成员函数
    val defaultStudent = Student.createDefaultStudent()
    println("默认学生：学号${defaultStudent.studentId}，班级${defaultStudent.className}")
}

扩展函数

内联函数

高阶函数

高级函数的核心特征：接收函数类型参数 或 返回函数类型；

核心前提：函数类型用于描述函数的签名（(参数列表) -> 返回值）；

两种常见形式：接收函数参数（最常用）、返回函数类型；

核心价值：提高代码复用性、灵活性，支撑函数式编程；

Kotlin 标准库内置大量高级函数，是日常开发的重要工具。

核心定义

在 Kotlin 中，高级函数是指满足以下两个条件之一的函数（二者满足其一即可，也可同时满足）：

1. 接受一个或多个函数类型作为参数（把函数当作 “参数” 传递给另一个函数）；
2. 返回值类型是一个函数类型（把函数当作 “返回结果” 返回给调用者）。

简单来说：高级函数打破了 “函数只能操作数据” 的限制，让函数可以作为另一个函数的输入（参数）或输出（返回值），这是函数式编程的核心特征。

核心前提：理解「函数类型」

要掌握高级函数，首先要理解「函数类型」—— 它是用来描述 “函数的签名” 的类型，就像Int描述整数、String描述字符串一样，函数类型描述函数的 “参数列表” 和 “返回值”。

函数类型的语法格式

// 格式1：无参数、有返回值（返回值为Int）
() -> Int

// 格式2：有参数、有返回值（参数为两个Int，返回值为Int）
(Int, Int) -> Int

// 格式3：有参数、无返回值（无返回值用Unit表示，等价于Java的void）
(String) -> Unit

关键说明

• 箭头左边是参数列表：多个参数用逗号分隔，无参数留空括号()；
• 箭头右边是返回值类型：无论函数是否有返回值，都必须指定（无返回值必须写Unit，不能省略）；
• 函数类型可以作为参数类型、返回值类型，这是高级函数的基础。

高级函数的两种核心形式（代码示例）

形式 1：接受函数类型作为参数（最常用）

这种高级函数接收一个或多个函数作为参数，在内部可以调用该传入的函数，实现 “逻辑注入”—— 即函数的核心流程固定，具体逻辑由传入的函数决定。

// 定义高级函数：接收两个Int参数，和一个(Int, Int) -> Int类型的函数参数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    // 内部调用传入的函数参数，执行具体逻辑
    return operation(a, b)
}

// 定义两个普通函数，用于传递给高级函数（符合(Int, Int) -> Int的函数类型）
fun add(x: Int, y: Int): Int = x + y
fun multiply(x: Int, y: Int): Int = x * y

fun main() {
    // 调用高级函数：传递add函数作为参数，实现加法逻辑
    val sumResult = calculate(10, 20, ::add)
    println("加法结果：$sumResult") // 输出：加法结果：30

    // 调用高级函数：传递multiply函数作为参数，实现乘法逻辑
    val mulResult = calculate(10, 20, ::multiply)
    println("乘法结果：$mulResult") // 输出：乘法结果：200

    // 简化写法：直接传递lambda表达式（无需提前定义普通函数）
    val subResult = calculate(10, 20) { x, y -> x - y }
    println("减法结果：$subResult") // 输出：减法结果：-10
}

关键说明：

• ::add 是 Kotlin 中的「函数引用」，用于将已定义的普通函数转换为函数类型，满足高级函数的参数要求；
• 当高级函数的最后一个参数是函数类型时，可以将 lambda 表达式移到括号外（称为 “尾随 lambda”），让代码更简洁。

形式 2：返回值是函数类型

这种高级函数本身执行后，会返回一个新的函数，后续可以调用这个返回的函数来完成具体逻辑。

// 定义高级函数：返回值类型是 (Int) -> Int（接收一个Int，返回一个Int）
fun createMultiplier(factor: Int): (Int) -> Int {
    // 返回一个lambda表达式（符合(Int) -> Int的函数类型）
    return { num -> num * factor }
}

fun main() {
    // 步骤1：调用高级函数，返回一个“乘以2”的函数
    val doubleFunc = createMultiplier(2)
    // 步骤2：调用返回的函数，执行具体逻辑
    val doubleResult = doubleFunc(10)
    println("10乘以2的结果：$doubleResult") // 输出：10乘以2的结果：20

    // 步骤1：调用高级函数，返回一个“乘以3”的函数
    val tripleFunc = createMultiplier(3)
    // 步骤2：调用返回的函数，执行具体逻辑
    val tripleResult = tripleFunc(10)
    println("10乘以3的结果：$tripleResult") // 输出：10乘以3的结果：30

    // 链式调用（简化写法）
    val result = createMultiplier(5)(20)
    println("20乘以5的结果：$result") // 输出：20乘以5的结果：100
}

关键说明：

• 高级函数createMultiplier的返回值类型是(Int) -> Int，它内部返回的 lambda 表达式必须匹配该函数类型；
• 变量doubleFunc、tripleFunc本质上是 “函数对象”，可以像普通函数一样调用（加括号传参）；
• 链式调用createMultiplier(5)(20)：先执行createMultiplier(5)返回一个函数，再用这个函数接收参数20执行。

高级函数的核心价值（为什么要用？）

1. 提高代码复用性：提取固定流程作为高级函数的核心逻辑，将变化的逻辑以函数参数的形式注入，避免重复编写相似代码（如上面的calculate函数，复用了 “接收两个数、执行运算、返回结果” 的流程，加法、乘法、减法逻辑可灵活替换）；
2. 增强代码灵活性：支持动态注入逻辑，让函数的行为更灵活，适应不同场景的需求；
3. 支撑函数式编程：是 Kotlin 中 lambda 表达式、集合操作（map、filter、reduce等）的底层基础，比如list.map { it * 2 }中的map就是一个高级函数；
4. 简化代码书写：结合 lambda 表达式，可以大幅简化代码，让代码更简洁、更具可读性。

补充：Kotlin 内置的高级函数示例

Kotlin 的标准库中提供了大量内置高级函数，日常开发中经常用到，比如：

1. 集合操作函数：map、filter、reduce、forEach

fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    
    // map 是高级函数，接收一个(Int) -> Any类型的函数参数
    val doubledList = list.map { it * 2 }
    println("翻倍后的列表：$doubledList") // 输出：翻倍后的列表：[2, 4, 6, 8, 10]
    
    // filter 是高级函数，接收一个(Int) -> Boolean类型的函数参数
    val evenList = list.filter { it % 2 == 0 }
    println("偶数列表：$evenList") // 输出：偶数列表：[2, 4]
}

2. 作用域函数：let、run、with、apply、also（均为高级函数）

fun main() {
    val str = "HelloKotlin"
    
    // let 是高级函数，接收一个(String) -> Unit类型的函数参数
    str.let {
        println("字符串长度：${it.length}")
        println("字符串转大写：${it.uppercase()}")
    }
}

中缀函数

扩展函数可以采用中缀函数的使用方式，但需要同时满足中缀函数的相关约束条件；中缀函数和扩展函数并非互斥概念，而是从两个不同维度对函数的分类。

1. 中缀函数是「调用语法」特殊，扩展函数是「功能扩展」机制，二者不互斥、可叠加；
2. 扩展函数可以用中缀方式调用，只需满足中缀函数的 4 个核心约束；
3. 中缀函数的核心价值是简化二元关系操作的代码，扩展函数的核心价值是无侵入式扩展已有类功能；
4. 中缀函数的两种存在形式：类成员函数、扩展函数（均需满足约束条件）。

中缀函数 vs 扩展函数：核心区别（维度不同）

两者的核心差异在于分类维度不同，这是理解两者关系的关键：

中缀函数的必备约束条件（无论是否为扩展函数）

要使用中缀语法调用函数，必须满足以下4 个严格约束，缺一不可：

1. 必须是成员函数或扩展函数：普通的顶层函数（不属于任何类、也不是扩展函数）无法被声明为中缀函数；
2. 必须只有一个参数：函数的参数列表中只能有一个参数，不能无参，也不能有多个参数；
3. 参数不能有默认值：该唯一参数不允许指定默认值（避免调用时的歧义）；
4. 必须用 infix 关键字修饰：在函数声明前显式添加 infix 关键字，标记该函数支持中缀调用语法。

扩展函数使用中缀调用方式的示例（可行）

下面通过代码示例，展示如何将扩展函数声明为中缀函数，并用中缀语法调用：

// 1. 定义：扩展函数 + 中缀函数（满足所有中缀约束）
// 为 String 类扩展一个中缀函数，用于判断字符串是否以指定后缀结尾（简化版 endsWith）
infix fun String.endsWithSuffix(suffix: String): Boolean {
    return this.endsWith(suffix)
}

// 2. 调用方式对比
fun main() {
    val str = "HelloKotlin"
    val suffix = "Kotlin"
    
    // 方式1：普通扩展函数调用方式（点号+括号）
    val result1 = str.endsWithSuffix(suffix)
    println("普通调用结果：$result1") // 输出：普通调用结果：true
    
    // 方式2：中缀函数调用方式（省略点号和括号，直接用空格分隔）
    val result2 = str endsWithSuffix suffix
    println("中缀调用结果：$result2") // 输出：中缀调用结果：true
}

再举一个更典型的二元关系示例（集合关联）：

// 为 List<Int> 扩展中缀函数，实现与另一个 List<String> 按索引关联
infix fun List<Int>.associateWithList(strList: List<String>): Map<Int, String> {
    val resultMap = mutableMapOf<Int, String>()
    for (i in indices) {
        if (i < strList.size) {
            resultMap[this[i]] = strList[i]
        }
    }
    return resultMap
}

fun main() {
    val nums = listOf(1, 2, 3)
    val words = listOf("A", "B", "C")
    
    // 中缀调用扩展函数，代码更简洁直观
    val associateMap = nums associateWithList words
    println(associateMap) // 输出：{1=A, 2=B, 3=C}
}

非扩展函数的中缀函数（类成员函数）

为了完整理解，这里给出类成员函数作为中缀函数的示例（对比扩展函数）：

// 定义一个简单的类
class Calculator(val base: Int) {
    // 类成员函数声明为中缀函数（满足约束：单个参数、无默认值、infix修饰）
    infix fun add(num: Int): Int {
        return base + num
    }
}

fun main() {
    val calc = Calculator(10)
    
    // 中缀调用类成员函数
    val result = calc add 20
    println(result) // 输出：30
    
    // 等价于普通调用
    val result2 = calc.add(20)
    println(result2) // 输出：30
}

Kotlin 中如何定义函数？有哪些特殊的函数类型？

Kotlin 中使用 fun 关键字定义函数，基本语法是：fun 函数名(参数列表): 返回类型 { 函数体 }。相比 Java，Kotlin 的函数定义更灵活、功能更强大。

// 基本函数定义
fun add(a: Int, b: Int): Int {
    return a + b
}

// 单表达式函数，可以省略花括号和 return
fun add2(a: Int, b: Int) = a + b

// 无返回值的函数，返回类型是 Unit（可省略）
fun printMessage(msg: String) {
    println(msg)
}

// 默认参数
fun greet(name: String, prefix: String = "你好") {
    println("$prefix，$name")
}

// 命名参数
greet(name = "张三", prefix = "早上好")
greet(name = "李四")  // 使用默认参数

Kotlin 还有一些特殊的函数类型。扩展函数可以为已有的类添加新方法，而不需要继承或修改原类。中缀函数允许用中缀表示法调用，让代码更自然。内联函数能减少 Lambda 的性能开销。高阶函数可以接收函数作为参数或返回函数。

// 扩展函数
fun String.addPrefix(prefix: String) = "$prefix$this"
val result = "世界".addPrefix("你好，")  // "你好，世界"

// 中缀函数
infix fun Int.times(str: String) = str.repeat(this)
val result2 = 3 times "嗨"  // "嗨嗨嗨"

// 高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}
val sum = calculate(5, 3) { x, y -> x + y }

1. 默认参数和命名参数的优势

默认参数和命名参数是 Kotlin 的贴心设计。在 Java 中，如果要支持多种参数组合，需要写多个重载方法，代码很冗余。Kotlin 的默认参数一个函数就能搞定。命名参数让函数调用更清晰，特别是参数很多时，不容易搞混参数顺序。

2. 扩展函数的强大之处

扩展函数是 Kotlin 最实用的特性之一。你可以为任何类添加方法，包括 Java 标准库的类。比如给 String 加个判空方法、给 List 加个自定义排序方法。这种能力让代码更优雅，不用写一堆工具类。需要注意的是，扩展函数是静态解析的，不能真正修改原类，也不能访问 private 成员。

3. 内联函数的性能优化

使用高阶函数和 Lambda 表达式会创建额外的对象，有一定性能开销。内联函数（inline）能让编译器把函数体直接插入到调用处，避免函数调用和对象创建的开销。Kotlin 标准库中的很多高阶函数都是内联的，比如 let、apply、also 等。如果你自己写高阶函数，也可以考虑用 inline 优化。

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    val end = System.currentTimeMillis()
    println("耗时：${end - start}ms")
    return result
}

4. 顶层函数简化工具类

Kotlin 允许在文件顶层直接定义函数，不需要放在类里面。这特别适合写工具方法，不用像 Java 那样创建工具类、定义静态方法。顶层函数编译后会变成静态方法，性能没有损失。这种设计让代码结构更清晰，避免了 Java 中到处都是 XxxUtil 类的情况。

Kotlin 中的扩展函数是什么？如何使用？

扩展函数是 Kotlin 最实用的特性之一，它允许你为已有的类添加新方法，而不需要继承这个类或者修改它的源代码。简单来说，就是给别人的类"打补丁"，加上你需要的功能。

扩展函数的定义语法是：fun 接收者类型.函数名(参数): 返回类型。在函数体内，可以用 this 访问接收者对象，通常 this 可以省略。

// 给 String 类添加一个扩展函数
fun String.addSuffix(suffix: String): String {
    return this + suffix  // this 指向调用对象
}

// 使用扩展函数
val result = "你好".addSuffix("，世界")
println(result)  // 输出：你好，世界

// 给 Int 添加扩展函数，判断是否为偶数
fun Int.isEven(): Boolean = this % 2 == 0

println(10.isEven())  // true
println(7.isEven())   // false

// 给 List 添加扩展函数，获取第二个元素
fun <T> List<T>.secondOrNull(): T? {
    return if (this.size >= 2) this[1] else null
}

val list = listOf("a", "b", "c")
println(list.secondOrNull())  // b

需要注意的是，扩展函数是静态解析的，不是真正修改了原类。它们不能访问类的 private 成员，本质上是编译器的语法糖，最终编译成静态方法。

1. 扩展函数的实现原理

扩展函数看起来像类的成员方法，但实际上是静态方法。编译器会把接收者对象作为第一个参数传给这个静态方法。比如 "abc".addSuffix("def") 会被编译成类似 StringExtKt.addSuffix("abc", "def") 的调用。理解这个原理，就能明白为什么扩展函数不能访问 private 成员，因为它不是真正的成员方法。

2. 扩展函数和成员函数的优先级

如果扩展函数和成员函数签名相同，成员函数的优先级更高。编译器会优先调用成员函数，扩展函数会被忽略。这是合理的设计，保证了类的原有行为不会被扩展函数意外覆盖。

class MyClass {
    fun foo() { println("成员函数") }
}

fun MyClass.foo() { println("扩展函数") }

MyClass().foo()  // 输出：成员函数

3. 可空类型的扩展

扩展函数还可以定义在可空类型上，这样即使对象为 null，也可以调用这个方法。这在处理可能为 null 的对象时特别有用。

fun String?.isNullOrEmpty2(): Boolean {
    return this == null || this.isEmpty()
}

val str: String? = null
println(str.isNullOrEmpty2())  // true，不会抛异常

4. 扩展函数的实际应用

在 Android 开发中，扩展函数被大量使用。比如给 View 添加点击防抖的扩展函数、给 Context 添加显示 Toast 的扩展函数、给 String 添加格式化的扩展函数等。Kotlin 标准库也提供了大量扩展函数，比如 let、apply、also 等作用域函数，还有集合的 map、filter 等操作。善用扩展函数能让代码更简洁、更符合直觉。建议把常用的工具方法都写成扩展函数，而不是传统的静态工具类。

Kotlin 中的高阶函数是什么？如何使用？

高阶函数是指接收函数作为参数，或者返回函数的函数。在 Kotlin 中，函数是一等公民，可以像其他类型一样作为参数传递和返回，这让高阶函数的使用非常自然。

// 接收函数作为参数的高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 使用高阶函数
val sum = calculate(5, 3) { x, y -> x + y }
val product = calculate(5, 3) { x, y -> x * y }
println(sum)      // 8
println(product)  // 15

// 返回函数的高阶函数
fun makeMultiplier(factor: Int): (Int) -> Int {
    return { num -> num * factor }
}

val double = makeMultiplier(2)
val triple = makeMultiplier(3)
println(double(5))  // 10
println(triple(5))  // 15

高阶函数让代码更灵活、更简洁。Kotlin 标准库中大量使用高阶函数，比如集合的 map、filter、fold 等操作，都是高阶函数。掌握高阶函数是写出优雅 Kotlin 代码的关键。

1. 函数类型的声明

在 Kotlin 中，函数类型用圆括号包含参数类型，箭头指向返回类型。比如 (Int, Int) -> Int 表示接收两个 Int 参数，返回 Int 的函数。函数类型本身也是一种类型，可以用于变量声明、参数类型、返回类型等。

// 函数类型的变量
val sum: (Int, Int) -> Int = { a, b -> a + b }

// 无参数的函数类型
val sayHello: () -> Unit = { println("Hello") }

// 接收函数类型的函数类型（高阶的高阶函数）
val higherOrder: ((Int) -> Int) -> Int = { func -> func(10) }

2. Lambda 表达式的简化

Kotlin 的 Lambda 表达式有很多简化写法。如果 Lambda 是函数的最后一个参数，可以放在括号外面。如果 Lambda 是唯一的参数，括号可以省略。如果 Lambda 只有一个参数，可以用 it 代替。这些简化让代码非常简洁。

// 完整写法
list.filter({ item -> item > 5 })

// Lambda 在括号外
list.filter() { item -> item > 5 }

// 省略空括号
list.filter { item -> item > 5 }

// 使用 it
list.filter { it > 5 }

3. 内联函数优化性能

使用高阶函数会创建 Lambda 对象，有一定性能开销。Kotlin 提供了 inline 关键字，让编译器把函数体和 Lambda 直接内联到调用处，避免对象创建。标准库的很多高阶函数都是内联的，所以性能不用担心。

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    val end = System.currentTimeMillis()
    println("耗时：${end - start}ms")
    return result
}

// 调用时，代码会被内联，没有额外开销
measureTime {
    // 一些耗时操作
}

4. 高阶函数在实际开发中的应用

在 Android 开发中，高阶函数被大量使用。比如事件监听（OnClickListener 可以用 Lambda 简化）、协程的 launch 和 async、Jetpack Compose 的声明式 UI、数据流转换等。掌握高阶函数能让代码更简洁、更函数式。很多框架的 DSL 风格 API 都是基于高阶函数实现的。

// 简化的点击监听
button.setOnClickListener { view ->
    println("点击了")
}

// 协程
launch {
    val result = async { fetchData() }
    updateUI(result.await())
}

// Compose UI
Column {
    Text("标题")
    Button(onClick = { /* 点击事件 */ }) {
        Text("按钮")
    }
}

Kotlin 中的 Lambda 表达式和匿名函数有什么区别？

Lambda 表达式和匿名函数都是创建函数字面值的方式，但它们在语法和行为上有一些区别。

Lambda 表达式是最常用的方式，语法简洁，用花括号包围，参数和函数体用箭头分隔。Lambda 中的 return 语句会从包含它的函数返回，这是非局部返回（non-local return）。

匿名函数使用 fun 关键字但没有函数名，语法更像普通函数。匿名函数中的 return 只从匿名函数本身返回，这是局部返回（local return）。

// Lambda 表达式
val lambda = { x: Int, y: Int -> x + y }

// 匿名函数
val anonymousFunc = fun(x: Int, y: Int): Int {
    return x + y
}

// return 行为的区别
fun testLambda() {
    val list = listOf(1, 2, 3, 4, 5)
    
    // Lambda：return 会从 testLambda 返回
    list.forEach {
        if (it == 3) return  // 从 testLambda 返回
        println(it)
    }
    println("这行不会执行")
}

fun testAnonymous() {
    val list = listOf(1, 2, 3, 4, 5)
    
    // 匿名函数：return 只从 forEach 返回
    list.forEach(fun(value: Int) {
        if (value == 3) return  // 只从这个匿名函数返回
        println(value)
    })
    println("这行会执行")  // 输出：1 2 4 5 这行会执行
}

在实际开发中，Lambda 表达式用得更多，因为语法更简洁。匿名函数主要用在需要明确的局部返回语义的场景，或者需要显式指定返回类型的场景。

1. 标签返回解决 Lambda 的返回问题

如果想在 Lambda 中实现局部返回，可以使用标签。给 Lambda 加上标签，然后用 return@标签 的方式返回。这样就不需要用匿名函数了。

fun testLabeledReturn() {
    val list = listOf(1, 2, 3, 4, 5)
    
    // 使用标签返回
    list.forEach label@{
        if (it == 3) return@label  // 只从 Lambda 返回
        println(it)
    }
    println("这行会执行")
    
    // 隐式标签（函数名）
    list.forEach {
        if (it == 3) return@forEach  // 使用函数名作为标签
        println(it)
    }
}

2. 内联函数和非局部返回

Lambda 的非局部返回只在内联函数中允许。如果高阶函数没有 inline，Lambda 中不能使用非限定的 return。这是因为非内联函数的 Lambda 会被编译成类，无法从外层函数返回。这种限制保证了代码的正确性。

// 内联函数允许非局部返回
inline fun inlineFunc(block: () -> Unit) {
    block()
}

// 非内联函数不允许
fun normalFunc(block: () -> Unit) {
    block()
}

fun test() {
    inlineFunc {
        return  // OK，因为是内联的
    }
    
    normalFunc {
        // return  // 编译错误
        return@normalFunc  // 必须用标签
    }
}

3. 类型推断的差异

Lambda 表达式的类型推断更智能，通常不需要显式声明参数类型。匿名函数有时需要显式声明返回类型，特别是有多个返回路径时。

// Lambda 类型推断
val list = listOf(1, 2, 3)
val doubled = list.map { it * 2 }  // 类型自动推断

// 匿名函数可能需要显式类型
val result = list.map(fun(x): Int {  // 显式返回类型
    if (x > 2) return x * 2
    return x
})

4. 选择使用哪种方式

在实际开发中，大部分情况用 Lambda 表达式就够了，语法简洁、类型推断好。只有在以下情况考虑匿名函数：需要明确的局部返回语义、有多个返回路径、需要显式声明返回类型、代码逻辑复杂用 Lambda 不清晰时。在 Android 开发中，99% 的场景 Lambda 就足够了，匿名函数用得很少。

Kotlin 的作用域函数（let、run、with、apply、also）有什么区别？

Kotlin 提供了五个作用域函数：let、run、with、apply、also，它们都用来在对象的上下文中执行代码块，但在引用方式和返回值上有区别。

主要区别在两个维度：一是在代码块中如何引用对象（用 this 还是 it），二是函数的返回值（返回代码块结果还是对象本身）。这五个函数虽然功能相似，但在实际使用中各有最佳场景。

下面用一个例子来展示这五个函数的不同用法和返回值：

data class User(var name: String, var age: Int)

val user = User("张三", 25)

// let：用 it 引用，返回代码块结果
val result1 = user.let {
    println("姓名：${it.name}")
    it.age + 10  // 返回这个值
}
println(result1)  // 35

// run：用 this 引用，返回代码块结果
val result2 = user.run {
    println("姓名：$name")  // this 可省略
    age + 10
}
println(result2)  // 35

// with：不是扩展函数，用 this 引用，返回代码块结果
val result3 = with(user) {
    println("姓名：$name")
    age + 10
}
println(result3)  // 35

// apply：用 this 引用，返回对象本身
val result4 = user.apply {
    name = "李四"  // 修改对象
    age = 30
}
println(result4)  // User(name=李四, age=30)

// also：用 it 引用，返回对象本身
val result5 = user.also {
    println("修改前：${it.name}")
    it.name = "王五"
}
println(result5)  // User(name=王五, age=30)

从上面的例子可以看出，let 和 run 返回代码块的最后一行结果，apply 和 also 返回对象本身。let 和 also 用 it 引用对象，run、with、apply 用 this 引用（可省略）。理解这些区别，选择合适的函数可以让代码更简洁优雅。

1. let 的典型应用场景

let 最常用的场景是配合安全调用处理可空对象。只有对象非空时才执行代码块，在代码块内对象就是非空的。let 还适合用于变量作用域限制和链式调用。下面是几个常见的使用场景：

// 处理可空对象
val name: String? = getName()
name?.let {
    println("姓名长度：${it.length}")
    saveToDatabase(it)
}

// 限制变量作用域
val result = getDa ta().let { data ->
    // data 只在这里可见
    processData(data)
}

// 链式调用
val result = listOf(1, 2, 3, 4, 5)
    .filter { it > 2 }
    .let { filtered ->
        println("过滤后的列表：$filtered")
        filtered.sum()
    }

2. apply 的典型应用场景

apply 返回对象本身，特别适合对象的初始化和配置。在构建复杂对象、配置视图属性、链式调用等场景很有用。在 Android 开发中，apply 被大量用于配置 View 和构建 Intent：

// 对象初始化
val user = User("张三", 25).apply {
    email = "zhangsan@example.com"
    phone = "13800138000"
}

// 视图配置
val textView = TextView(context).apply {
    text = "标题"
    textSize = 18f
    setTextColor(Color.BLACK)
}

// 链式配置
Intent(this, MainActivity::class.java).apply {
    putExtra("key1", "value1")
    putExtra("key2", "value2")
    flags = Intent.FLAG_ACTIVITY_NEW_TASK
}.let {
    startActivity(it)
}