编辑“︁Kotlin对象表达式”︁

{{Note|本文介绍Kotlin的对象表达式（Object Expressions），这是Kotlin中一种创建匿名对象的方式，类似于Java的匿名内部类，但功能更强大。}}

== 介绍 ==
在Kotlin中，'''对象表达式（Object Expressions）'''用于创建匿名类的实例，这些匿名类可以继承自某个类或实现某个接口。对象表达式在需要临时创建一个对象而不必显式声明子类时非常有用。它们通常用于一次性使用的对象，例如事件监听器或回调。

对象表达式的语法类似于对象声明（Object Declarations），但对象表达式是表达式，可以赋值给变量或作为参数传递。

== 基本语法 ==
对象表达式的基本语法如下：
<syntaxhighlight lang="kotlin">
val obj = object : SuperType() {
    // 属性或方法的实现
}
</syntaxhighlight>

其中：
* `SuperType` 可以是类或接口。
* 如果 `SuperType` 是一个类，可以调用其构造函数（如 `SuperType()`）。
* 在花括号 `{}` 内，可以重写父类的方法或添加新的属性和方法。

=== 示例：实现接口 ===
以下是一个简单的示例，展示如何使用对象表达式实现一个接口：
<syntaxhighlight lang="kotlin">
interface Greeter {
    fun greet(name: String)
}

fun main() {
    val greeter = object : Greeter {
        override fun greet(name: String) {
            println("Hello, $name!")
        }
    }
    greeter.greet("Kotlin") // 输出：Hello, Kotlin!
}
</syntaxhighlight>

=== 示例：继承类 ===
对象表达式也可以继承自一个类：
<syntaxhighlight lang="kotlin">
open class Person(val name: String) {
    open fun greet() {
        println("Hi, I'm $name.")
    }
}

fun main() {
    val person = object : Person("Alice") {
        override fun greet() {
            println("Hello, my name is $name!")
        }
    }
    person.greet() // 输出：Hello, my name is Alice!
}
</syntaxhighlight>

== 对象表达式的特性 ==
=== 1. 可以访问外部作用域的变量 ===
与Java的匿名内部类不同，Kotlin的对象表达式可以访问并修改外部作用域的变量（包括非final变量）：
<syntaxhighlight lang="kotlin">
fun main() {
    var count = 0
    val counter = object {
        fun increment() {
            count++
        }
    }
    counter.increment()
    println(count) // 输出：1
}
</syntaxhighlight>

=== 2. 可以同时继承类和实现接口 ===
对象表达式可以同时继承一个类并实现多个接口：
<syntaxhighlight lang="kotlin">
interface A {
    fun foo()
}

interface B {
    fun bar()
}

open class C {
    open fun baz() {
        println("C.baz")
    }
}

fun main() {
    val obj = object : C(), A, B {
        override fun foo() {
            println("foo")
        }
        override fun bar() {
            println("bar")
        }
        override fun baz() {
            println("overridden baz")
        }
    }
    obj.foo() // 输出：foo
    obj.bar() // 输出：bar
    obj.baz() // 输出：overridden baz
}
</syntaxhighlight>

=== 3. 匿名对象的类型 ===
匿名对象的类型是动态生成的，无法在代码中显式引用。如果需要将其作为返回值或赋值给变量，可以使用父类或接口类型：
<syntaxhighlight lang="kotlin">
interface Processor {
    fun process()
}

fun createProcessor(): Processor {
    return object : Processor {
        override fun process() {
            println("Processing...")
        }
    }
}

fun main() {
    val processor = createProcessor()
    processor.process() // 输出：Processing...
}
</syntaxhighlight>

== 实际应用场景 ==
=== 1. 事件监听器 ===
对象表达式常用于实现事件监听器，例如Android中的按钮点击事件：
<syntaxhighlight lang="kotlin">
button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View?) {
        println("Button clicked!")
    }
})
</syntaxhighlight>

=== 2. 临时对象 ===
当需要一个临时对象时，可以使用对象表达式：
<syntaxhighlight lang="kotlin">
fun createTempConfig(): Any {
    return object {
        val timeout = 5000
        val retries = 3
    }
}
</syntaxhighlight>

=== 3. 替代Java的匿名内部类 ===
在Kotlin中，对象表达式可以完全替代Java的匿名内部类，且语法更简洁：
<syntaxhighlight lang="kotlin">
Thread(object : Runnable {
    override fun run() {
        println("Thread running")
    }
}).start()
</syntaxhighlight>

== 对象表达式 vs 对象声明 ==
Kotlin中还有另一种类似的概念：'''对象声明（Object Declarations）'''，即使用 `object` 关键字声明的单例对象。以下是两者的对比：

{| class="wikitable"
|-
! 特性 !! 对象表达式 !! 对象声明
|-
| 语法 | `val obj = object { ... }` | `object Singleton { ... }`
|-
| 生命周期 | 每次调用时创建新实例 | 单例，首次访问时初始化
|-
| 用途 | 临时匿名对象 | 全局单例或伴生对象
|}

== 注意事项 ==
1. 对象表达式不能有构造函数，因为它们是匿名的。
2. 匿名对象的类型是动态生成的，无法在代码中显式引用。
3. 对象表达式可以访问并修改外部作用域的变量，但需注意线程安全问题。

== 总结 ==
Kotlin的对象表达式是一种强大的特性，用于创建匿名类的实例。它们可以：
* 实现接口或继承类。
* 访问并修改外部作用域的变量。
* 用于事件监听器、临时对象等场景。

通过对象表达式，Kotlin提供了一种比Java匿名内部类更灵活的方式来创建匿名对象。

== 练习 ==
尝试以下练习以巩固所学知识：
1. 创建一个对象表达式，实现 `Runnable` 接口并打印 "Running in a thread"。
2. 编写一个函数，返回一个匿名对象，该对象包含 `name` 和 `age` 属性。

{{Hint|练习1的参考实现：
<syntaxhighlight lang="kotlin">
val runnable = object : Runnable {
    override fun run() {
        println("Running in a thread")
    }
}
Thread(runnable).start()
</syntaxhighlight>
}}

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin面向对象编程]]