在 Kotlin 中实现 单例模式(Singleton Pattern)非常简单,Kotlin 提供了内建的 object 关键字,专门用来创建单例。使用 object 时,Kotlin 会自动保证类只有一个实例,并且这个实例在整个应用生命周期内是唯一的。
下面是实现单例模式的几种常见方式。
1. 使用 object
关键字实现单例
最简单的方式是直接使用 Kotlin 的 object
关键字。这样定义的类会在第一次使用时初始化,并且在整个程序中只有一个实例。
示例:
object Singleton {
val value = 42
fun printMessage() {
println("Hello from Singleton!")
}
}
fun main() {
// 通过 Singleton 对象访问成员
println(Singleton.value) // 输出:42
Singleton.printMessage() // 输出:Hello from Singleton!
}
解释:
object Singleton 定义了一个单例对象,value 和 printMessage 是这个单例的成员。
Kotlin 会自动保证 Singleton 只有一个实例,并且在首次访问时初始化。
2. 通过伴生对象实现单例
如果你已经有一个类,并且想在其中实现单例模式,可以使用伴生对象(companion object)来定义一个单例。
示例:
class MyClass private constructor() {
companion object {
private var instance: MyClass? = null
fun getInstance(): MyClass {
if (instance == null) {
instance = MyClass()
}
return instance!!
}
}
}
fun main() {
val myClass1 = MyClass.getInstance()
val myClass2 = MyClass.getInstance()
println(myClass1 === myClass2) // 输出:true,证明它们是同一个实例
}
解释:
MyClass
的构造函数是私有的,这样外部无法直接创建对象。- 在伴生对象中,我们定义了一个静态方法
getInstance()
,通过它来返回单例实例。 instance
变量保存了唯一的实例,只有在首次调用getInstance()
时才会创建实例。
3. 使用 by lazy
延迟初始化
Kotlin 还提供了 lazy
委托,它会在第一次访问时初始化对象,因此可以使用它来实现线程安全的单例。
示例:
class Singleton private constructor() {
companion object {
val instance: Singleton by lazy {
Singleton()
}
}
}
fun main() {
val singleton1 = Singleton.instance
val singleton2 = Singleton.instance
println(singleton1 === singleton2) // 输出:true,证明它们是同一个实例
}
解释:
- 使用
by lazy
可以延迟对象的创建,直到第一次访问时才会创建实例。 - 这种方式是线程安全的,因为 Kotlin 会在多线程环境下自动处理初始化的同步。
总结
- 最简单的单例:直接使用
object
关键字。 - 伴生对象单例:如果你需要在已有的类中创建单例,可以使用
companion object
。 - 延迟初始化:使用
by lazy
可以确保延迟初始化且线程安全。
————————————————
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
原文链接:https://blog.csdn.net/qq_16318175/article/details/145317756