Kotlin入門-Day8：物件導向

2024/06/29閱讀時間約 8 分鐘

類別（Class）

Kotlin 中的類別（class）是面向對象編程的基本單位，它封裝了數據和行為。以下是有關 Kotlin 類別的各種概念及其示例。

建構子（Constructor）

Kotlin 中有主建構子和次建構子。

// 主建構子
class Person(val name: String, var age: Int)

// 次建構子
class Person {
    var name: String
    var age: Int

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

公開（Public）

public 是預設的訪問修飾符，表示所有地方都能訪問。

class Person {
    public var name: String = "John"
}

私有（Private）

private 表示只有在類別內部才能訪問。

class Person {
    private var name: String = "John"
}

保護（Protected）

protected 表示在類別及其子類中可以訪問。

open class Person {
    protected var name: String = "John"
}

class Student : Person() {
    fun printName() {
        println(name)  // 可以訪問
    }
}

內部（Internal）

internal 表示在同一模組中可以訪問。

internal class Person {
    var name: String = "John"
}

繼承（Inheritance）

Kotlin 支持類別繼承，但類別默認是 final 的，需要用 open 修飾符標記為可繼承。

open class Person {
    open fun greet() {
        println("Hello!")
    }
}

class Student : Person() {
    override fun greet() {
        println("Hi, I am a student.")
    }
}

多型（Polymorphism）

多型允許使用不同的類別類型來處理相同的基本行為。

open class Animal {
    open fun sound() {
        println("Animal sound")
    }
}

class Dog : Animal() {
    override fun sound() {
        println("Bark")
    }
}

class Cat : Animal() {
    override fun sound() {
        println("Meow")
    }
}

fun makeSound(animal: Animal) {
    animal.sound()
}

val dog = Dog()
val cat = Cat()

makeSound(dog)  // 輸出: Bark
makeSound(cat)  // 輸出: Meow

封裝（Encapsulation）

封裝通過訪問修飾符來控制對類別內部數據和方法的訪問。

class Person {
    private var name: String = "John"

    fun getName(): String {
        return name
    }
}

介面（Interface）

介面定義一組行為，其他類別可以實現這些行為。

interface Drivable {
    fun drive()
}

class Car : Drivable {
    override fun drive() {
        println("Car is driving")
    }
}

val car = Car()
car.drive()  // 輸出: Car is driving

抽象類別（Abstract Class）

抽象類別不能實例化，可以包含抽象方法和具體方法。

abstract class Animal {
    abstract fun sound()

    fun sleep() {
        println("Sleeping")
    }
}

class Dog : Animal() {
    override fun sound() {
        println("Bark")
    }
}

val dog = Dog()
dog.sound()  // 輸出: Bark
dog.sleep()  // 輸出: Sleeping

靜態類別（Static Class）

Kotlin 中沒有 static 關鍵字，可以使用 companion object 來模擬靜態行為。

class Utility {
    companion object {
        fun printMessage() {
            println("This is a static message")
        }
    }
}

Utility.printMessage()  // 輸出: This is a static message

列舉（Enumerations）

列舉用於表示一組相關的常量。

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

val direction = Direction.NORTH
println(direction)  // 輸出: NORTH

委派（Delegates）

委派模式允許一個對象將其操作委派給另一個對象。

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() {
        println(x)
    }
}

class Derived(b: Base) : Base by b

val b = BaseImpl(10)
val derived = Derived(b)
derived.print()  // 輸出: 10

Lambda 表達式

Lambda 表達式是一種簡潔的函數表示方式。

val sum: (Int, Int) -> Int = { x, y -> x + y }
println(sum(3, 4))  // 輸出: 7

泛型（Generics）

泛型允許類別和函數操作任意類型。

class Box<T>(val value: T)

val intBox = Box(1)
val stringBox = Box("Hello")
println(intBox.value)  // 輸出: 1
println(stringBox.value)  // 輸出: Hello

反射（Reflection）

反射允許在運行時檢查和操作對象。

import kotlin.reflect.full.*

class MyClass(val name: String, val age: Int)

fun main() {
    val myClass = MyClass::class
    println(myClass.simpleName)  // 輸出: MyClass
    myClass.memberProperties.forEach { println(it.name) }  // 輸出: name, age
}