Kotlin对象创建[编辑 | 编辑源代码]

在Kotlin中，对象创建是面向对象编程的核心操作之一，涉及类的实例化过程。Kotlin提供了多种灵活的对象创建方式，包括构造函数、伴生对象、对象表达式等，每种方式适用于不同的场景。

基本概念[编辑 | 编辑源代码]

对象创建是指通过类定义生成具体实例的过程。在Kotlin中，所有对象都继承自Any类（类似于Java的Object），但语法更简洁且支持更多特性。

类与对象的关系[编辑 | 编辑源代码]

对象创建方式[编辑 | 编辑源代码]

1. 主构造函数实例化[编辑 | 编辑源代码]

最基础的方式是通过主构造函数创建对象：

class Person(val name: String, var age: Int)

fun main() {
    val person = Person("Alice", 25)  // 对象创建
    println("${person.name} is ${person.age} years old") 
}

输出:

Alice is 25 years old

2. 次构造函数[编辑 | 编辑源代码]

当类需要多种初始化方式时：

class User {
    constructor(name: String) {
        println("Created user $name")
    }
    
    constructor(id: Int) {
        println("Created user with ID $id")
    }
}

fun main() {
    val user1 = User("Bob")
    val user2 = User(1001)
}

输出:

Created user Bob
Created user with ID 1001

3. 对象表达式（匿名对象）[编辑 | 编辑源代码]

用于创建一次性使用的对象：

fun createRunnable(): Runnable {
    return object : Runnable {
        override fun run() {
            println("Anonymous object running")
        }
    }
}

fun main() {
    createRunnable().run()
}

输出:

Anonymous object running

4. 对象声明（单例）[编辑 | 编辑源代码]

Kotlin特有的单例实现方式：

object DatabaseManager {
    init {
        println("Database connection established")
    }
    
    fun query(sql: String) = "Result for '$sql'"
}

fun main() {
    println(DatabaseManager.query("SELECT * FROM users"))
}

输出:

Database connection established
Result for 'SELECT * FROM users'

5. 伴生对象[编辑 | 编辑源代码]

类级别的单例实例：

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

fun main() {
    val instance = MyClass.create()
    println(instance::class.simpleName)
}

输出:

MyClass

高级特性[编辑 | 编辑源代码]

初始化顺序[编辑 | 编辑源代码]

对象创建时的初始化顺序遵循：

主构造函数参数
类属性初始化器
init块
次构造函数体

示例：

class InitOrderDemo(name: String) {
    val firstProperty = "First property: $name".also(::println)
    
    init {
        println("First initializer block")
    }
    
    val secondProperty = "Second property".also(::println)
    
    init {
        println("Second initializer block")
    }
}

fun main() {
    InitOrderDemo("test")
}

输出:

First property: test
First initializer block
Second property
Second initializer block

延迟初始化[编辑 | 编辑源代码]

使用lateinit推迟初始化：

class Service {
    lateinit var api: ExternalAPI
    
    fun initialize() {
        api = ExternalAPI()
    }
}

class ExternalAPI {
    fun connect() = println("Connected")
}

fun main() {
    val service = Service()
    service.initialize()
    service.api.connect()
}

输出:

Connected

实际应用案例[编辑 | 编辑源代码]

案例1：配置读取器[编辑 | 编辑源代码]

object AppConfig {
    private const val FILE_PATH = "config.properties"
    private val props = java.util.Properties()
    
    init {
        props.load(java.io.FileInputStream(FILE_PATH))
    }
    
    fun getProperty(key: String) = props.getProperty(key)
}

fun main() {
    println("Database URL: ${AppConfig.getProperty("db.url")}")
}

案例2：抽象工厂模式[编辑 | 编辑源代码]

interface Device {
    fun play()
}

class Phone : Device {
    override fun play() = println("Playing on phone")
}

class Tablet : Device {
    override fun play() = println("Playing on tablet")
}

object DeviceFactory {
    fun createDevice(type: String): Device {
        return when(type.lowercase()) {
            "phone" -> Phone()
            "tablet" -> Tablet()
            else -> throw IllegalArgumentException("Unknown device")
        }
    }
}

fun main() {
    val device = DeviceFactory.createDevice("phone")
    device.play()
}