编辑“︁Kotlin对象创建”︁（章节）

= Kotlin对象创建 =

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

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

=== 类与对象的关系 ===
<mermaid>
classDiagram
    class Class {
        +properties
        +methods()
    }
    class Object {
        +concrete values
    }
    Class --> Object : 实例化
</mermaid>

== 对象创建方式 ==

=== 1. 主构造函数实例化 ===
最基础的方式是通过主构造函数创建对象：

<syntaxhighlight lang="kotlin">
class Person(val name: String, var age: Int)

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

'''输出:'''
<pre>
Alice is 25 years old
</pre>

=== 2. 次构造函数 ===
当类需要多种初始化方式时：

<syntaxhighlight lang="kotlin">
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)
}
</syntaxhighlight>

'''输出:'''
<pre>
Created user Bob
Created user with ID 1001
</pre>

=== 3. 对象表达式（匿名对象） ===
用于创建一次性使用的对象：

<syntaxhighlight lang="kotlin">
fun createRunnable(): Runnable {
    return object : Runnable {
        override fun run() {
            println("Anonymous object running")
        }
    }
}

fun main() {
    createRunnable().run()
}
</syntaxhighlight>

'''输出:'''
<pre>
Anonymous object running
</pre>

=== 4. 对象声明（单例） ===
Kotlin特有的单例实现方式：

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

fun main() {
    println(DatabaseManager.query("SELECT * FROM users"))
}
</syntaxhighlight>

'''输出:'''
<pre>
Database connection established
Result for 'SELECT * FROM users'
</pre>

=== 5. 伴生对象 ===
类级别的单例实例：

<syntaxhighlight lang="kotlin">
class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

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

'''输出:'''
<pre>
MyClass
</pre>

== 高级特性 ==

=== 初始化顺序 ===
对象创建时的初始化顺序遵循：
# 主构造函数参数
# 类属性初始化器
# init块
# 次构造函数体

<mermaid>
flowchart TD
    A[主构造函数参数] --> B[属性初始化]
    B --> C[init块]
    C --> D[次构造函数体]
</mermaid>

示例：
<syntaxhighlight lang="kotlin">
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")
}
</syntaxhighlight>

'''输出:'''
<pre>
First property: test
First initializer block
Second property
Second initializer block
</pre>

=== 延迟初始化 ===
使用<code>lateinit</code>推迟初始化：

<syntaxhighlight lang="kotlin">
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()
}
</syntaxhighlight>

'''输出:'''
<pre>
Connected
</pre>

== 实际应用案例 ==

=== 案例1：配置读取器 ===
<syntaxhighlight lang="kotlin">
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")}")
}
</syntaxhighlight>

=== 案例2：抽象工厂模式 ===
<syntaxhighlight lang="kotlin">
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()
}
</syntaxhighlight>

'''输出:'''
<pre>
Playing on phone
</pre>

== 数学原理 ==
对象创建过程可以形式化为：
<math>
\text{Object} = \text{Class} \times \text{ConstructorParameters} \rightarrow \text{MemoryAllocation}
</math>

其中：
* <math>\text{Class}</math> 是类型定义
* <math>\text{ConstructorParameters}</math> 是参数空间
* <math>\rightarrow</math> 表示内存分配过程

== 最佳实践 ==
1. 优先使用主构造函数
2. 复杂初始化逻辑放在<code>init</code>块中
3. 需要延迟初始化时使用<code>lateinit</code>
4. 全局单例使用<code>object</code>声明
5. 避免在构造函数中执行耗时操作

{{Warning|对象创建可能引发异常（如参数校验失败），应做好错误处理}}

== 参见 ==
* [[Kotlin类与继承]]
* [[Kotlin构造函数]]
* [[Kotlin单例模式实现]]

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