Kotlin 类与对象 #

class Person {
    var name: String = ""
    var age: Int = 0
    
    fun greet() {
        println("Hello, I'm $name")
    }
}

val person = Person()
person.name = "Kotlin"
person.age = 10
person.greet()  // Hello, I'm Kotlin

class Empty

// 或
class Empty()

class Person {
    // 可变属性
    var name: String = ""
    
    // 只读属性
    val id: Int = 1
    
    // 延迟初始化
    lateinit var email: String
    
    // 懒加载
    val heavyData: Data by lazy {
        loadData()
    }
}

class Person {
    var name: String = ""
        get() = field.uppercase()
        set(value) {
            field = value.trim()
        }
    
    var age: Int = 0
        set(value) {
            field = if (value >= 0) value else 0
        }
}

class Counter {
    var count: Int = 0
        get() = field
        set(value) {
            if (value >= 0) {
                field = value
            }
        }
}

class Rectangle(val width: Int, val height: Int) {
    val area: Int
        get() = width * height
    
    val isSquare: Boolean
        get() = width == height
}

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

val person = Person("Kotlin", 10)

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

class Person(val name: String, var age: Int) {
    // 次构造函数
    constructor(name: String) : this(name, 0)
    
    constructor() : this("Unknown", 0)
}

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

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

class Example {
    public var publicProp: String = ""      // 所有可见
    private var privateProp: String = ""    // 类内可见
    protected var protectedProp: String = "" // 类及子类可见
    internal var internalProp: String = ""  // 模块内可见
    
    private fun privateMethod() { }
    
    public fun publicMethod() { }
}

// 公开类
public class PublicClass

// 文件内私有
private class PrivateClass

// 模块内可见
internal class InternalClass

class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
    
    fun multiply(a: Int, b: Int) = a * b
}

class Printer {
    fun print(message: String, prefix: String = "[INFO]") {
        println("$prefix $message")
    }
}

val printer = Printer()
printer.print("Hello")           // [INFO] Hello
printer.print("Hello", "[WARN]") // [WARN] Hello

class Math {
    fun add(a: Int, b: Int) = a + b
    fun add(a: Double, b: Double) = a + b
    fun add(a: Int, b: Int, c: Int) = a + b + c
}

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

val user = User(1, "Kotlin", "kotlin@example.com")

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

// 自动生成：
// - equals()
// - hashCode()
// - toString()
// - copy()
// - componentN()

val user = User(1, "Kotlin")
println(user)  // User(id=1, name=Kotlin)

// copy
val updated = user.copy(name = "Updated")
println(updated)  // User(id=1, name=Updated)

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

val user = User(1, "Kotlin")
val (id, name) = user

println("ID: $id, Name: $name")

class Outer {
    val outerProp = "Outer"
    
    class Nested {
        fun greet() = "Hello from Nested"
    }
}

val nested = Outer.Nested()
nested.greet()

class Outer {
    val outerProp = "Outer"
    
    inner class Inner {
        fun greet() = "Hello from Inner, $outerProp"
    }
}

val outer = Outer()
val inner = outer.Inner()
inner.greet()  // Hello from Inner, Outer

interface ClickListener {
    fun onClick()
}

class Button {
    var listener: ClickListener? = null
    
    fun click() {
        listener?.onClick()
    }
}

val button = Button()
button.listener = object : ClickListener {
    override fun onClick() {
        println("Button clicked")
    }
}
button.click()

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()

class MyClass {
    companion object : Logger {
        override fun log(message: String) {
            println(message)
        }
    }
}

MyClass.log("Hello")

class User(
    val id: Int,
    val name: String,
    private var _email: String
) {
    val email: String
        get() = _email.lowercase()
    
    var password: String = ""
        private set
    
    fun updatePassword(newPassword: String) {
        password = newPassword
    }
    
    fun validate(): Boolean {
        return name.isNotBlank() && email.contains("@")
    }
}

class User private constructor(
    val name: String,
    val age: Int,
    val email: String
) {
    class Builder {
        private var name: String = ""
        private var age: Int = 0
        private var email: String = ""
        
        fun name(name: String) = apply { this.name = name }
        fun age(age: Int) = apply { this.age = age }
        fun email(email: String) = apply { this.email = email }
        
        fun build() = User(name, age, email)
    }
}

val user = User.Builder()
    .name("Kotlin")
    .age(10)
    .email("kotlin@example.com")
    .build()

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

Database.query("SELECT * FROM users")

// 推荐
data class User(val id: Int, val name: String)

// 不推荐（手动实现）
class User(val id: Int, val name: String) {
    override fun equals(other: Any?): Boolean { }
    override fun hashCode(): Int { }
    override fun toString(): String { }
}

// 推荐
class Person {
    var age: Int = 0
        private set
    
    fun updateAge(newAge: Int) {
        if (newAge >= 0) age = newAge
    }
}

// 推荐
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
    }
}