Kotlin 构造函数 #

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

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

// val 参数：只读属性
// var 参数：可变属性
// 无修饰符：仅构造参数
class Person(
    val name: String,    // 属性
    var age: Int,        // 属性
    id: Int              // 仅参数
) {
    val idString = "ID: $id"
}

class Person(
    val name: String = "Unknown",
    var age: Int = 0
)

val p1 = Person()
val p2 = Person("Kotlin")
val p3 = Person("Kotlin", 10)
val p4 = Person(age = 10)

class Person(val name: String, var age: Int) {
    init {
        println("Initializing Person")
        require(age >= 0) { "Age cannot be negative" }
    }
}

class Person(val name: String) {
    init {
        println("First init: $name")
    }
    
    val upperName = name.uppercase()
    
    init {
        println("Second init: $upperName")
    }
}

class Example {
    val a = 1.also { println("a = $it") }
    
    init {
        println("First init")
    }
    
    val b = 2.also { println("b = $it") }
    
    init {
        println("Second init")
    }
}

// 输出顺序：
// a = 1
// First init
// b = 2
// Second init

class Person(val name: String, var age: Int) {
    constructor(name: String) : this(name, 0) {
        println("Secondary constructor")
    }
}

class Person(val name: String, var age: Int) {
    constructor(name: String) : this(name, 0)
    
    constructor(age: Int) : this("Unknown", age)
    
    constructor() : this("Unknown", 0)
}

val p1 = Person("Kotlin", 10)
val p2 = Person("Kotlin")
val p3 = Person(10)
val p4 = Person()

class Person(val name: String, var age: Int) {
    init {
        println("Init block")
    }
    
    constructor(name: String) : this(name, 0) {
        println("Secondary constructor body")
    }
}

val p = Person("Kotlin")
// 输出：
// Init block
// Secondary constructor body

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

val singleton = Singleton.instance

class User private constructor(val id: Int, val name: String) {
    companion object {
        fun create(id: Int, name: String): User {
            return User(id, name)
        }
        
        fun createGuest(): User {
            return User(0, "Guest")
        }
    }
}

val user = User.create(1, "Kotlin")
val guest = User.createGuest()

class Person(
    val name: String,
    val email: String? = null
)

val p1 = Person("Kotlin")
val p2 = Person("Kotlin", "kotlin@example.com")

class Person(
    val name: String,
    val createdAt: Long = System.currentTimeMillis()
)

val p = Person("Kotlin")

class Button(
    val text: String,
    val onClick: () -> Unit = {}
)

val button = Button("Click") {
    println("Clicked!")
}

open class Person(val name: String)

class Student(name: String, val grade: Int) : Person(name)

// 或
class Student(name: String, val grade: Int) : Person(name.uppercase())

open class Person(val name: String) {
    constructor(name: String, age: Int) : this(name)
}

class Student : Person {
    constructor(name: String) : super(name)
    
    constructor(name: String, age: Int) : super(name, age)
}

// 主构造函数至少有一个参数
data class User(val id: Int, val name: String)

// 参数必须是 val 或 var
// data class Invalid(id: Int)  // 错误

data class User(val id: Int, val name: String, val email: String)

val user = User(1, "Kotlin", "kotlin@example.com")
val updated = user.copy(name = "Updated")
// User(id=1, name=Updated, email=kotlin@example.com)

class Config private constructor(
    val host: String,
    val port: Int,
    val ssl: Boolean
) {
    class Builder {
        private var host: String = "localhost"
        private var port: Int = 8080
        private var ssl: Boolean = false
        
        fun host(host: String) = apply { this.host = host }
        fun port(port: Int) = apply { this.port = port }
        fun ssl(ssl: Boolean) = apply { this.ssl = ssl }
        
        fun build(): Config {
            return Config(host, port, ssl)
        }
    }
    
    companion object {
        fun builder() = Builder()
    }
}

val config = Config.builder()
    .host("example.com")
    .port(443)
    .ssl(true)
    .build()

class Email private constructor(val value: String) {
    companion object {
        fun of(value: String): Email? {
            return if (value.contains("@")) {
                Email(value)
            } else {
                null
            }
        }
    }
}

val email = Email.of("kotlin@example.com")  // Email
val invalid = Email.of("invalid")           // null

class Service(val config: Config) {
    private lateinit var connection: Connection
    
    fun connect() {
        connection = Connection(config)
    }
    
    fun isConnected(): Boolean {
        return ::connection.isInitialized
    }
}

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

// 不推荐
class Person {
    var name: String = ""
    var age: Int = 0
    
    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

// 推荐
class Person(val name: String = "Unknown", var age: Int = 0)

// 不推荐
class Person {
    constructor(name: String, age: Int)
    constructor(name: String) : this(name, 0)
    constructor() : this("Unknown", 0)
}

class Person(val name: String, var age: Int) {
    init {
        require(name.isNotBlank()) { "Name cannot be blank" }
        require(age >= 0) { "Age cannot be negative" }
    }
}