一、对象表达式
用于创建匿名对象的语法
1
2
3
4
5
6
7
| val obj = object : SomeType(parameters), AnotherType {
// 对象表达式的成员
}
//如果没有任何操作或超类的话，也可以简化为
val helloWorld = object {
}
|
二、使用场景
1. 创建匿名对象
1
2
3
4
5
6
7
| //当你只需要一个临时的、单个的对象，并不打算在其他地方复用它时，对象表达式是很有用的。
val runnable = object : Runnable {
override fun run() {
// 实现 Runnable 接口的匿名对象
}
}
|
2. 实现接口
1
2
3
4
5
6
7
| // 对象表达式常用于实现接口，特别是只需要在一个地方使用的接口实现
val myClickListener = object : View.OnClickListener {
override fun onClick(view: View) {
// 处理点击事件
}
}
|
3. 继承类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| //可以使用对象表达式创建继承自某个类的匿名子类。
val myThread = object : Thread() {
override fun run() {
// 线程执行的任务
}
}
//有参数时传递参数，还可以额外实现需要的接口
open class A(x: Int) {
public open val y: Int = x
}
interface B { /*...*/ }
val ab: A = object : A(1), B {
override val y = 15
}
|
三、对象声明
常用于单例模式，直接使用object进行修饰即可，对象声明不同于对象表达式，不能直接放在赋值语句右侧
1
2
3
4
5
6
7
8
9
10
11
| object DataProviderManager {
fun registerDataProvider(provider: DataProvider) {
// ...
}
val allDataProviders: Collection<DataProvider>
get() = // ...
}
//使用时直接通过名称进行调用
DataProviderManager.registerDataProvider(...)
|
对象声明是可以有父类的
1
2
3
4
5
| object DefaultListener : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) { ... }
override fun mouseEntered(e: MouseEvent) { ... }
}
|
通常还回与data class 结合变为 data object ，两则大致相同，但data object 没有 copy，componentN方法，后者更适合用在一些状态的表示上
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| sealed interface ReadResult
data class Number(val number: Int) : ReadResult
data class Text(val text: String) : ReadResult
data object EndOfFile : ReadResult
fun printReadResult(r: ReadResult) {
when(r) {
is Number -> println("Num(${r.number}")
is Text -> println("Txt(${r.text}")
is EndOfFile -> println("EOF")
}
}
fun main() {
printReadResult(EndOfFile) // EOF
}
|
四、伴生对象
类似于java中的静态成员方法
1
2
3
4
5
6
7
8
|
class MyClass1 {
companion object Named { }
}
//Named可以省略，默认名称Companion
class MyClass1 {
companion object { }
}
|
伴生对象可以实现接口
1
2
3
4
5
6
7
8
9
10
11
| interface Factory<T> {
fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass()
}
}
val f: Factory<MyClass> = MyClass
|
本质上是创建了一个名为Companion的静态单例内部类
通常可以在伴生对象中去实例化对象，达到构造函数的效果。
