kotlin类与对象——>对象表达式与对象声明、内联类

1.对象表达式与对象声明

　　有时候，我们需要创建一个对某个类做了轻微改动的类的对象，而不用为之显式声明新的子类。Kotlin 用对象表达式和对象声明处理这种情况

2.对象表达式

　　要创建一个继承自某个(或某些)类型的匿名类的对象，我们会这么写:

window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { /*......*/
    }

    override fun mouseEntered(e: MouseEvent) { /*......*/
    }
})

　　如果超类型有一个构造函数，则必须传递适当的构造函数参数给它。多个超类型可以由跟在冒号后面的逗号分隔的列表指定:

open class A(x: Int) {
    public open val y: Int = x
}

interface B { /*......*/ }

val ab: A = object : A(1), B {
    override val y = 15
}

　　任何时候，如果我们只需要“一个对象而已”，并不需要特殊超类型，那么我们可以简单地写

fun foo() {
    val adHoc = object {
        var x: Int = 0
        var y: Int = 0
    }
    print(adHoc.x + adHoc.y)
}

　　　请注意，匿名对象可以用作只在本地和私有作用域中声明的类型。如果你使用匿名对象作为公有函数的返回类型或者用作公有属性的类型，那么该函数或属性的实际类型会是匿名对象声明的超类型，如果你没有声明任何超类型，就会是 Any 。在匿名对象中添加的成员将无法访问。

class C {
    // 私有函数，所以其返回类型是匿名对象类型 
    private fun foo() = object {
        val x: String = "x"
    }

    // 公有函数，所以其返回类型是 Any
    fun publicFoo() = object {
        val x: String = "x"
    }

    fun bar() {
        val x1 = foo().x // 没问题
        val x2 = publicFoo().x // 错误:未能解析的引用“x”
    }
}

　　对象表达式中的代码可以访问来自包含它的作用域的变量

fun countClicks(window: JComponent) {
    var clickCount = 0
    var enterCount = 0
    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++
        }

        override fun mouseEntered(e: MouseEvent) {
            enterCount++
        }
    })
// ......
}

2.对象声明

　　单例模式在一些场景中很有用，而 Kotlin(继 Scala 之后)使单例声明变得很容易:

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ......
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ......
}

　　这称为对象声明。并且它总是在 object 关键字后跟一个名称。就像变量声明一样，对象声明不是一个表达式，不能用在赋值语句的右边。

　　对象声明的初始化过程是线程安全的并且在首次访问时进行。如需引用该对象，我们直接使用其名称即可:

DataProviderManager.registerDataProvider(......)

　　这些对象可以有超类型:

object DefaultListener : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        ......
    }

    override fun mouseEntered(e: MouseEvent) {
        ......
    }
}

　　注意:对象声明不能在局部作用域(即直接嵌套在函数内部)，但是它们可以嵌套到其他对象声明或非内部类中。

3.伴生对象

　　类内部的对象声明可以用 companion 关键字标记:

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

　　该伴生对象的成员可通过只使用类名作为限定符来调用:

val instance = MyClass.create()

　　可以省略伴生对象的名称，在这种情况下将使用名称 Companion :

class MyClass {
    companion object {}
}

val x = MyClass.Companion

　　其自身所用的类的名称(不是另一个名称的限定符)可用作对该类的伴生对象(无论是否具名)的引用:

class MyClass1 {
    companion object Named {}
}

val x = MyClass1

class MyClass2 {
    companion object {}
}

val y = MyClass2

　　请注意，即使伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口

interface Factory<T> {
    fun create(): T
}

class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass = MyClass()
    }
}

val f: Factory<MyClass> = MyClass

　　当然，在 JVM 平台，如果使用 @JvmStatic 注解，你可以将伴生对象的成员生成为真正的静态方法和字段。更详细信息请参⻅Java 互操作性一节。

4.对象表达式和对象声明之间的语义差异

对象表达式和对象声明之间有一个重要的语义差别:
— 对象表达式是在使用他们的地方立即执行(及初始化)的;
— 对象声明是在第一次被访问到时延迟初始化的;
— 伴生对象的初始化是在相应的类被加载(解析)时，与Java静态初始化器的语义相匹配。

5.类型别名：

　　类型别名为现有类型提供替代名称。如果类型名称太⻓，你可以另外引入较短的名称，并使用新的名称替代原类型名。

　　它有助于缩短较⻓的泛型类型。

　　5.1 例如，通常缩减集合类型是很有吸引力的:

typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>

　　5.2 你可以为函数类型提供另外的别名

typealias MyHandler = (Int, String, Any) -> Unit
typealias Predicate<T> = (T) -> Boolean

　　5.3 你可以为内部类和嵌套类创建新名称:

class A {
    inner class Inner
}

class B {
    inner class Inner
}
typealias AInner = A.Inner
typealias BInner = B.Inner

　　5.4 类型别名不会引入新类型。它们等效于相应的底层类型。当你在代码中添加 typealias Predicate<T> 并使用 Predicate<Int> 时，Kotlin 编译器总是把它扩展为 (Int) -> Boolean 。因此，当你需要泛型函数类型时，你可以传递该类型的变量，反之亦然:

typealias Predicate<T> = (T) -> Boolean

fun foo(p: Predicate<Int>) = p(42)

fun main() {
    
    val f: (Int) -> Boolean = { it > 0 }
    println (foo(f)) // 输出 "true"
    val p: Predicate<Int> = { it > 0 }
    println(listOf(1, -2).filter(p)) // 输出 "[1]"

}

6.内联类：内联类仅在 Kotlin 1.3 之后版本可用，目前还是实验性的

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

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

inline class Password(val value: String)

　　内联类必须含有唯一的一个属性在主构造函数中初始化。在运行时，将使用这个唯一属性来表示内联类的实例

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

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

7.成员

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

inline class Name(val s: String) {
    val length: Int
        get() = s.length

    fun greet() {
        println("Hello, $s")
    }
}

fun main() {
    val name = Name("Kotlin")
    name.greet() // `greet` 方法会作为一个静态方法被调用 
    println(name.length) // 属性的 get 方法会作为一个静态方法被调用
}

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

— 内联类不能含有init代码块
— 内联类不能含有幕后字段
    — 因此，内联类只能含有简单的计算属性(不能含有延迟初始化/委托属性)

8.继承

　　内联类允许去继承接口

interface Printable {
    fun prettyPrint(): String
}

inline class Name(val s: String) : Printable {
    override fun prettyPrint(): String = "Let's $s!"
}

fun main() {
    val name = Name("Kotlin")
    println(name.prettyPrint()) // 仍然会作为一个静态方法被调用
}

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

9.表示方式

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

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

interface I
inline class Foo(val i: Int) : I

fun asInline(f: Foo) {}
fun <T> asGeneric(x: T) {}
fun asInterface(i: I) {}
fun asNullable(i: Foo?) {}

fun <T> id(x: T): T = x

fun main() {
    val f = Foo(42)
    asInline(f) // 拆箱操作: 用作 Foo 本身
    asGeneric(f) // 装箱操作: 用作泛型类型 T
    asInterface(f) // 装箱操作: 用作类型 I
    asNullable(f) // 装箱操作: 用作不同于 Foo 的可空类型 Foo?
// 在下面这里例子中，'f' 首先会被装箱(当它作为参数传递给 'id' 函数时)然后又被拆箱(当它从'id'函数 中被返回时)
// 最后， 'c' 中就包含了被拆箱后的内部表达(也就是 '42')， 和 'f' 一样
    val c = id(f)
}

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

10.名字修饰

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

inline class UInt(val x: Int)

// 在 JVM 平台上被表示为'public final void compute(int x)'
fun compute(x: Int) { }

// 同理，在 JVM 平台上也被表示为'public final void compute(int x)'!
fun compute(x: UInt) { }

　　为了缓解这种问题，一般会通过在函数名后面拼接一些稳定的哈希码来重命名函数。

compute(x: UInt) 
//将会被表示为
 public final void compute-<hashcode>(int x) 
//以 此来解决冲突的问题。
//请注意在 Java 中 - 是一个 无效的 符号，也就是说在 Java 中不能调用使用内联类作为形参的函数

11.内联类和类标别名

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

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

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

typealias NameTypeAlias = String

inline class NameInlineClass(val s: String)

fun acceptString(s: String) {}
fun acceptNameTypeAlias(n: NameTypeAlias) {}
fun acceptNameInlineClass(p: NameInlineClass) {}
fun main() {
    val nameAlias: NameTypeAlias = ""
    val nameInlineClass: NameInlineClass = NameInlineClass("")
    val string: String = ""
    acceptString(nameAlias) // 正确: 传递别名类型的实参替代函数中基础类型的形参 
    acceptString(nameInlineClass) // 错误: 不能传递内联类的实参替代函数中基础类型的形参
    // And vice versa:
    acceptNameTypeAlias(string) // 正确: 传递基础类型的实参替代函数中别名类型的形参
    acceptNameInlineClass(string) // 错误: 不能传递基础类型的实参替代函数中内联类类型的形参
}

12.内联类的实验性状态

　　内联类的设计目前是实验性的，这就是说此特性是正在快速变化的，并且不保证其兼容性。在 Kotlin 1.3+ 中使用内联类时，将会得到一个警告，来表明此特性还是实验性的。

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

13.在 Gradle 中启用内联类

compileKotlin {
    kotlinOptions.freeCompilerArgs += ["-Xinline-classes"]
}

tasks.withType<KotlinCompile> { 
    kotlinOptions.freeCompilerArgs += "-Xinline-classes"
}

14.在 Maven 中启用内联类

<configuration>
    <args>
        <arg>-Xinline-classes</arg> 
    </args>
</configuration>

原文地址：https://www.cnblogs.com/developer-wang/p/13213507.html