金三银四必备，全面总结 Kotlin 面试知识点

作者：彭旭锐

前言

• 在 Android 面试中很重视基础知识的考察，其中语言基础主要包括 Java、Kotlin、C/C++ 三种编程语言。在小彭面试的经验中，发现很多同学的 Kotlin 语言能力只是停留在一些非常入门的语法使用上；
• 在这篇文章里，我将为你浓缩总结 Kotlin 中最常用的知识点和原理。希望通过这篇文章能够帮助你扫除支持盲区，对于一些语法背后的原理也有所涉猎。

---

1. 为什么要使用 Kotlin？

面试官问这个问题一方面可能是先想引入 Kotlin 这个话题，另一方面是想考察你的认知能力，是不是真的有思考过 Kotlin 的优势 / 价值，还是随波逐流别人用我也跟着用。你可以这么回答：

在 Android 生态中主要有 C++、Java、Kotlin 三种语言 ，它们的关系不是替换而是互补。其中，C++ 的语境是算法和高性能，Java 的语境是平台无关和内存管理，而 Kotlin 则融合了多种语言中的优秀特性，带来了一种更现代化的编程方式。 例如简化异步编程的协程（coroutines），提高代码质量的可空性（nullability），lambda 表达式等。

2. 语法糖的味道

• == 和 equal() 相同，=== 比较内存地址

• 顶级成员（函数 & 属性）的原理： Kotlin 顶级成员的本质是 Java 静态成员，编译后会自动生成文件名Kt的类，可以使用@Jvm:fileName注解修改自动生成的类名。

• 默认参数的原理： Kotlin 默认参数的本质是将默认值 固化 到调用位置，所以在 Java 中无法直接调用带默认参数的函数，需要在 Kotlin 函数上增加@JvmOverloads注解，指示编译器生成重载方法（@JvmOverloads会为默认参数提供重载方法）。

• 解构声明的原理： Kotlin 解构声明可以把一个对象的属性分解为一组变量，所以解构声明的本质是局部变量。

  举例：

    val (name, price) = Book("Kotlin入门", 66.6f)
    println(name)
    println(price)

-------------------------------------------
Kotlin 类需要声明`operator fun componentN()`方法来实现解构功能，否则是不具备解构声明的功能的，例如：

    class Book(var name: String, var price: Float) {
        operator fun component1(): String { // 解构的第一个变量
            return name
        }

        operator fun component2(): Float { // 解构的第二个变量
            return price
        }
    }

• Sequences 序列的原理： Sequences 提升性能的关键在于多个操作共享同一个 Iterator 迭代器，只需要一次循环就可以完成数据操作。Sequences 又是懒惰的，需要遇到终端操作才会开始工作。

• 扩展函数的原理： 扩展函数的语义是在不修改类 / 不继承类的情况下，向一个类添加新函数或者新属性。本质是静态函数，静态函数的第一个参数是接收者类型，调用扩展时不会创建适配对象或者任何运行时的额外消耗。在 Java 中，我们只需要像调用普通静态方法那样调用扩展即可。相关资料：Kotlin | 扩展函数（终于知道为什么 with 用 this，let 用 it）

• let、apply、with 的区别和应用场景： let、with、apply 都是标准库函数，它们的主要区别在 lambda 参数类型定义不同。apply、with 的 lambda 参数是 T 的扩展函数，因此在 lambda 内使用 this 引用接收者对象，而 let 的 lambda 参数是参数为 T 的高阶函数，因此 lambda 内使用 it 引用唯一参数。

• 委托机制的原理： Kotlin 委托的语法关键字是 by，其本质上是面向编译器的语法糖，三种委托（类委托、对象委托和局部变量委托）在编译时都会转化为 “无糖语法”。例如类委托：编译器会实现基础接口的所有方法，并直接委托给基础对象来处理。例如对象委托和局部变量委托：在编译时会生成辅助属性（prop$degelate），而属性 / 变量的 getter() 和 setter() 方法只是简单地委托给辅助属性的 getValue() 和 setValue() 处理。相关资料：Kotlin | 委托机制 & 原理 & 应用

• 中缀函数： 声明 infix 关键字的函数是中缀函数，调用中缀函数时可以省略圆点以及圆括号等程序符号，让语句更自然。

  中缀函数的要求：

  • 1、成员函数或扩展函数
  • 2、函数只有一个参数
  • 3、不能使用可变参数或默认参数

  举例：

    infix fun String.吃(fruit: String): String {
        return "${this}吃${fruit}"
    }
    调用： "小明" 吃 "苹果"

---

3. 类型系统

• 数值类型： Kotlin 将基本数据类型和引用型统一为：Byte、Short、Int、Long、Float、Double、Char 和 Boolean。需要注意的是，类型的统一并不意味着 Kotlin 所有的数值类型都是引用类型，大多数情况下，它们在编译后会变成基本数据类型，类型参数会被编译为引用类型。

• 隐式转换： Kotlin 不存在隐式类型转换，即时是低级类型也需要显式转换为高级类型：

    //隐式转换，编译器会报错
    val anInt: Int = 5
    val ccLong: Long = anInt 

    //需要去显式的转换,下面这个才是正确的 
    val ddLong: Long = anInt.toLong()

• 平台类型： 当可空性注解不存在时，Java 类型会被转换为 Kotlin 的平台类型。平台类型本质上是 Kotlin 编译器无法确定其可空信息，既可以把它当作可空类型，也可以把它当作非空类型。

  如果所有来自 Java 的值都被看成非空是不合理的，反之把 Java 值都当作可空的，由会引出大量 Null 检查。综合考量，平台类型是 Kotlin 为开发者选择的折中的设计方案。

• 类型转换： 较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。

    val b: Byte = 1 // OK
    val i: Int = b // 编译错误
    val i: Int = b.toInt() // OK

• 只读集合和可变集合： 只读集合只可读，而可变集合可以增删该差（例如 List 只读，MutableList 可变）。需要注意，只读集合引用指向的集合不一定是不可变的，因为你使用的变量可能是众多指向同一个集合的其中一个。

• Array 和 IntArray 的区别： Array 相当于引用类型数组 Integer[]，IntArray 相当于数值类型数组 int[]。

• Unit： Any 的子类，作为函数返回值时表示没有返回值，可以省略，与 Java void 类似。

• Nothing： 表示表达式或者函数永远不会返回，Nothing? 唯一允许的值是 null。

• Java Void： void 的包装类，与 void 类似表示一个函数没有有效的返回值，返回值只能是 null。

---

4. 面向对象

• 类修饰符： Kotlin 类 / 方法默认是 final 的，如果想让继承类 / 重写方法，需要在基类 / 基方法添加 open 修饰符。

    final：不允许继承或重写
    open：允许继承或重写
    abstract：抽象类 / 抽象方法

• 访问修饰符： Java 默认的访问修饰符是 protected，Kotlin 默认的访问修饰符是 public。

public：所有地方可见
    internal：模块中可见，一个模块就是一组编译的 Kotlin 文件
    protected：子类中可见（与 Java 不同，相同包不可见，Kotlin 没有 default 包可见）
    private：类中可见

• 构造函数：

  • 默认构造函数： class 默认有一个无参主构造函数，如果显式声明了构造函数，则默认的无参主构造函数失效；
  • 主构造函数： 声明在 class 关键字后，其中 constructor 关键词可以省略；
  • 次级构造函数： 如果声明了次级构造函数，则默认的无参主构造函数会失效。如果存在主构造函数，次级构造函数需要直接或间接委托给主构造函数。

• init 函数执行顺序： 主构造函数 > init > 次级构造函数

• 内部类： Kotlin 默认为静态内部类，如果想访问类中的成员方法和属性，需要添加 inner 关键字称为非静态内部类；Java 默认为非静态内部类。

• data 关键字原理： data 关键字用于定义数据类型，编译器会自动从主构造函数中提取属性并生成一系列函数：equals()/hashCode()、toString()、componentN()、copy()。

• sealed 关键字原理： 密封类用来表示受限的类继承结构，密封类可以有子类，但是所有子类都必须内嵌在该密封类中。

• object 与 companion object 的区别 object 有两层语义：静态匿名内部类 + 单例对象 companion object 是伴生对象，一个类只能有一个，代表了类的静态成员（函数 / 属性）

• 单例： Kotlin 可以使用 Java 相似的方法实现单例，也可以采用 Kotlin 特有的语法。相关资料：Kotlin下的5种单例模式

  • object

    // Kotlin实现
    object SingletonDemo

*   **by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED)**

class SingletonDemo private constructor() {
        companion object {
            val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
    		        SingletonDemo() 
    				}
        }
    }

• 泛型： 关于泛型能问的都在这里了（含Kotlin）

---

5. lambda 表达式

• lambda 表达式本质上是「可以作为值传递的代码块」。在老版本 Java 中，传递代码块需要使用匿名内部类实现，而使用 lambda 表达式甚至连函数声明都不需要，可以直接传递代码块作为函数值。

• it： 当 lambda 表达式只有一个参数，可以用 it 关键字来引用唯一的实参。

• lambda 表达式的种类

  • 1、普通 Lambda 表达式：例如 ()->R
  • 2、带接收者对象的 Lambda 表达式：例如 T.()->R

• lambda 表达式访问局部变量的原理： 在 Java 中，匿名内部类访问的局部变量必须是 final 修饰的，否则需要使用数组或对象做一层包装。在 Kotlin 中，lambda 表达式可以直接访问非 final 的局部变量，其原理是提供了一层包装类，修改局部变量本质上是修改包装类中的属性。

    class Ref<T>(var value:T)

• lambda 表达式编译优化： 在循环中使用 Java 8 与 Kotlin 中的 lambda 表达式时，会存在编译时优化，编译器会将 lambda 优化为一个 static 变量，除非 lambda 表达式中访问了外部的变量或函数。

• inline 内联函数的原理：

  • 内联 lambda 表达式参数（主要优点）： 内联函数的参数如果是 lambda 表达式，则该参数默认也是 inline 的。lambda 表达式也会被固化的函数调用位置，从而减少了为 lambda 表达式创建匿名内部类对象的开销。当 lambda 表达式被经常调用时，可以减少内存开销。

  • 减少入栈出栈过程（次要优点）： 内联函数的函数体被固化到函数调用位置，执行过程中减少了栈帧创建、入栈和出栈过程。需要注意：如果函数体太大就不适合使用内联函数了，因为会大幅度增加字节码大小。

  • @PublishApi 注解： 编译器要求内联函数必须是 public 类型，使用 @PublishApi 注解可以实现 internal 等访问修饰的同时又实现内联

  • noinline 非内联： 如果在内联函数内部，lambda 表达式参数被其它非内联函数调用，会报编译时错误。这是因为 lambda 表达式已经被拉平而无法传递给其他非内联函数。可以给参数加上 noinline 关键字表示禁止内联。

inline fun test(noinline inlined: () -> Unit) {
            otherNoinlineMethod(inlined)
        }

*   **非局部返回（Non-local returns）：** 一个不带标签的 return 语句只能用在 fun 声明的函数中使用，因此在 lambda 表达式中的 return 必须带标签，指明需要 return 的是哪一级的函数：

fun song(f: (String) -> Unit) {
            // do something
        }

        fun behavior() {
            song {
                println("song $it")
                return //报错: 'return' is not allowed here
                return@song // 局部返回
                return@behavior // 非局部返回
            }
        }

    唯一的例外是在内联函数中的 lambda 表达式参数，可以直接使用不带标签的 return，返回的是调用内联函数的外部函数，而不是内联函数本身，默认就是非局部返回。

inline fun song(f: (String) -> Unit) {
            // do something
        }

        fun behavior() {
            song {
                println("song $it")
                return // 非局部返回
                return@song // 局部返回
                return@behavior // 非局部返回
            }
        }

*   **crossinline 非局部返回：** 禁止内联函数的 lambda 表达式参数使用非局部返回

*   **实化类型参数 reified：** 因为泛型擦除的影响，运行期间不清楚类型实参的类型，Kotlin 中使用 **带实化类型参数的内联函数** 可以突破这种限制。实化类型参数在插入到调用位置时会使用类型实参的确切类型代替，因此可以确定实参类型。


    在这个函数里，我们传入一个List，企图从中过滤出 T 类型的元素：

        Java：
        <T> List<T> filter(List list) {
            List<T> result = new ArrayList<>();
            for (Object e : list) {
                if (e instanceof T) { // compiler error
                    result.add(e);
                }
            }
            return result;
        }
        ---------------------------------------------------
        Kotlin：
        fun <T> filter(list: List<*>): List<T> {
            val result = ArrayList<T>()
            for (e in list) {
                if (e is T) { // cannot check for instance of erased type: T
                    result.add(e)
                }
            }
            return result
        }

        调用：
        val list = listOf("", 1, false)
        val strList = filter<String>(list)
        ---------------------------------------------------
        内联后：
        val result = ArrayList<String>()
        for (e in list) {
            if (e is String) {
                result.add(e)
            }
        }

---

5. DSL 领域特定语言

DSL 是专门用于解决某个问题的语言，虽然没有通用语言那么全面，但在解决特定问题时更加高效。案例：Compose 的 UI 代码也是采用了 DSL，使得 Compose 拥有了不输于 XML 的编码效率。实现 DSL 需要可以利用的 Kotlin 语法特性，相关资料：Kotlin DSL 实战：像 Compose 一样写代码

• 高阶函数： 使得 lambda 参数脱离圆括号，减少一个参数；

• 扩展函数： 传递 Receiver，减少一个参数；

• Context Receivers： 传递多个 Receiver，在扩展函数的基础上减少多个参数；

• 中缀函数： 让语法更简洁自然；

• @DSLMarker： 用于限制 lambda 中不带标签的 this 只能访问到最近的 Receiver 类型，当调用更外层的 Receiver 时必须显式指定 this@XXX。

context(View)
    val Float.dp 
        get() = this * this@View.resources.displayMetrics.density

    class SomeView : View {
      val someDimension = 4f.dp
    }

---

6. 总结

少部分比较聪明的小伙伴就会问了，你这怎么没有涉及协程、Flow 这些知识点？那是因为这些知识点比较多，小彭决定单独放在一篇文章里。一篇文章拆成两篇用，它不香吗？