Kotlin 对象与伴生对象 #

object Database {
    private val connections = mutableListOf<Connection>()
    
    fun connect(): Connection {
        val connection = Connection()
        connections.add(connection)
        return connection
    }
    
    fun disconnectAll() {
        connections.clear()
    }
}

Database.connect()
Database.disconnectAll()

object Singleton {
    init {
        println("Singleton initialized")
    }
    
    var count = 0
    
    fun increment() = count++
}

Singleton.increment()
Singleton.increment()
println(Singleton.count)  // 2

object Printer {
    fun print(message: String) {
        println(message)
    }
}

fun usePrinter(printer: Printer) {
    printer.print("Hello")
}

usePrinter(Printer)

class MyClass {
    companion object {
        const val CONSTANT = "Constant"
        
        fun staticMethod() {
            println("Static method")
        }
    }
}

MyClass.CONSTANT
MyClass.staticMethod()

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

MyClass.create()
MyClass.Factory.create()

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

class User(val name: String) {
    companion object : Factory<User> {
        override fun create(): User = User("Default")
    }
}

val user = User.create()

class MyClass {
    companion object
}

fun MyClass.Companion.extension() {
    println("Extension function")
}

MyClass.extension()

interface ClickListener {
    fun onClick()
}

val listener = object : ClickListener {
    override fun onClick() {
        println("Clicked")
    }
}

listener.onClick()

open class Handler {
    open fun handle() {
        println("Handling")
    }
}

val handler = object : Handler() {
    override fun handle() {
        println("Custom handling")
    }
}

fun countClicks(): Int {
    var clicks = 0
    
    val listener = object : ClickListener {
        override fun onClick() {
            clicks++
        }
    }
    
    listener.onClick()
    listener.onClick()
    
    return clicks
}

object Database {
    fun query(sql: String): List<Any> {
        return emptyList()
    }
}

class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy { Singleton() }
    }
}

val singleton = Singleton.instance

class Singleton private constructor() {
    companion object {
        @Volatile
        private var instance: Singleton? = null
        
        fun getInstance(): Singleton {
            return instance ?: synchronized(this) {
                instance ?: Singleton().also { instance = it }
            }
        }
    }
}

object AppConfig {
    var apiUrl: String = "https://api.example.com"
    var timeout: Long = 30000
    var debug: Boolean = false
    
    fun load(config: Map<String, Any>) {
        apiUrl = config["apiUrl"] as? String ?: apiUrl
        timeout = config["timeout"] as? Long ?: timeout
        debug = config["debug"] as? Boolean ?: debug
    }
}

AppConfig.load(mapOf(
    "apiUrl" to "https://prod.example.com",
    "debug" to true
))

interface Shape {
    fun draw()
}

class Circle : Shape {
    override fun draw() = println("Drawing Circle")
}

class Square : Shape {
    override fun draw() = println("Drawing Square")
}

object ShapeFactory {
    fun create(type: String): Shape {
        return when (type.lowercase()) {
            "circle" -> Circle()
            "square" -> Square()
            else -> throw IllegalArgumentException("Unknown shape: $type")
        }
    }
}

val circle = ShapeFactory.create("circle")
circle.draw()

object Logger {
    private var level = LogLevel.INFO
    
    enum class LogLevel {
        DEBUG, INFO, WARN, ERROR
    }
    
    fun setLevel(level: LogLevel) {
        this.level = level
    }
    
    fun debug(message: String) {
        if (level <= LogLevel.DEBUG) println("[DEBUG] $message")
    }
    
    fun info(message: String) {
        if (level <= LogLevel.INFO) println("[INFO] $message")
    }
    
    fun warn(message: String) {
        if (level <= LogLevel.WARN) println("[WARN] $message")
    }
    
    fun error(message: String) {
        if (level <= LogLevel.ERROR) println("[ERROR] $message")
    }
}

Logger.info("Application started")
Logger.error("Something went wrong")

interface Callback {
    fun onSuccess(result: String)
    fun onError(error: String)
}

fun fetchData(callback: Callback) {
    try {
        Thread.sleep(100)
        callback.onSuccess("Data loaded")
    } catch (e: Exception) {
        callback.onError(e.message ?: "Unknown error")
    }
}

fetchData(object : Callback {
    override fun onSuccess(result: String) {
        println("Success: $result")
    }
    
    override fun onError(error: String) {
        println("Error: $error")
    }
})

// 使用 object：全局单例
object Database { }

// 使用 companion object：与类关联的静态成员
class User {
    companion object {
        fun create() = User()
    }
}

// 推荐
object Singleton {
    fun doSomething() { }
}

// 不推荐
class Singleton private constructor() {
    companion object {
        val instance = Singleton()
    }
}

class Constants {
    companion object {
        const val MAX_SIZE = 100
        const val DEFAULT_TIMEOUT = 30000L
    }
}

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User {
            return User(name.trim())
        }
        
        fun createGuest(): User {
            return User("Guest")
        }
    }
}