内联类

    有时候，业务逻辑需要围绕某种类型创建包装器。然而，由于额外的堆内存分配问题，它会引入运行时的性能开销。此外，如果被包装的类型是原生类型，性能的损失是很糟糕的，因为原生类型通常在运行时就进行了大量优化，然而他们的包装器却没有得到任何特殊的处理。

    为了解决这类问题，Kotlin 引入了一种被称为 的特殊类，它通过在类的前面定义一个 inline 修饰符来声明：

    内联类必须含有唯一的一个属性在主构造函数中初始化。在运行时，将使用这个唯一属性来表示内联类的实例（关于运行时的内部表达请参阅）：

    1. // 不存在 'Password' 类的真实实例对象
    2. // 在运行时，'securePassword' 仅仅包含 'String'
    3. val securePassword = Password("Don't try this in production")

    这就是内联类的主要特性，它灵感来源于 “inline” 这个名称：类的数据被 “内联”到该类使用的地方（类似于内联函数中的代码被内联到该函数调用的地方）。

    内联类支持普通类中的一些功能。特别是，内联类可以声明属性与函数：

    1. inline class Name(val s: String) {
    2.     val length: Int
    3.         get() = s.length
    5.     fun greet() {
    6.         println("Hello, $s")
    7.     }
    8. }    
    10. fun main() {
    11.     name.greet() // `greet` 方法会作为一个静态方法被调用
    12.     println(name.length) // 属性的 get 方法会作为一个静态方法被调用
    13. }

    然而，内联类的成员也有一些限制：

    • 内联类不能含有 init 代码块
    • 内联类不能含有
      • 因此，内联类只能含有简单的计算属性（不能含有延迟初始化/委托属性）

    继承

    禁止内联类参与到类的继承关系结构中。这就意味着内联类不能继承其他的类而且必须是 final。

    在生成的代码中，Kotlin 编译器为每个内联类保留一个包装器。内联类的实例可以在运行时表示为包装器或者基础类型。这就类似于 Int 可以表示为原生类型 int 或者包装器 Integer。

    为了生成性能最优的代码，Kotlin 编译更倾向于使用基础类型而不是包装器。 然而，有时候使用包装器是必要的。一般来说，只要将内联类用作另一种类型，它们就会被装箱。

    3. inline class Foo(val i: Int) : I
    5. fun asInline(f: Foo) {}
    6. fun <T> asGeneric(x: T) {}
    7. fun asInterface(i: I) {}
    8. fun asNullable(i: Foo?) {}
    10. fun <T> id(x: T): T = x
    12. fun main() {
    13.     val f = Foo(42) 
    15.     asInline(f)    // 拆箱操作: 用作 Foo 本身
    16.     asGeneric(f)   // 装箱操作: 用作泛型类型 T
    17.     asNullable(f)  // 装箱操作: 用作不同于 Foo 的可空类型 Foo?
    19.     // 在下面这里例子中，'f' 首先会被装箱（当它作为参数传递给 'id' 函数时）然后又被拆箱（当它从'id'函数中被返回时）
    20.     // 最后， 'c' 中就包含了被拆箱后的内部表达(也就是 '42')， 和 'f' 一样
    21.     val c = id(f)

    因为内联类既可以表示为基础类型有可以表示为包装器，对于内联类而言毫无意义，因此这也是被禁止的。

    由于内联类被编译为其基础类型，因此可能会导致各种模糊的错误，例如意想不到的平台签名冲突：

    1. inline class UInt(val x: Int)
    3. // 在 JVM 平台上被表示为'public final void compute(int x)'
    4. fun compute(x: Int) { }
    6. // 同理，在 JVM 平台上也被表示为'public final void compute(int x)'！
    7. fun compute(x: UInt) { }

    为了缓解这种问题，一般会通过在函数名后面拼接一些稳定的哈希码来重命名函数。 因此，fun compute(x: UInt) 将会被表示为 public final void compute-<hashcode>(int x)，以此来解决冲突的问题。

    内联类与类型别名

    初看起来，内联类似乎与类型别名非常相似。实际上，两者似乎都引入了一种新的类型，并且都在运行时表示为基础类型。

    然而，关键的区别在于类型别名与其基础类型(以及具有相同基础类型的其他类型别名)是 赋值兼容 的，而内联类却不是这样。

    换句话说，内联类引入了一个真实的新类型，与类型别名正好相反，类型别名仅仅是为现有的类型取了个新的替代名称(别名)：

    内联类的设计处于 版，这意味着对于未来版本没有兼容性保证。在 Kotlin 1.3+ 中使用内联类时，会报一个警告，提示该特性尚未稳定发布。

    如需移除警告，必须通过指定编译器参数 -Xinline-classes 来选择使用这项特性。

    1. kotlin {
    2.     sourceSets.all {
    3.         languageSettings.enableLanguageFeature('InlineClasses')
    4.     }
    5. }
    1. kotlin {
    2.     sourceSets.all {
    3.         languageSettings.enableLanguageFeature("InlineClasses")
    4.     }

    关于详细信息，请参见编译器选项。关于的设置，请参见使用 Gradle 构建多平台项目章节。 参见。

    进一步讨论

    关于其他技术详细信息和讨论，请参见内联类的语言提议