Kotlin革命：次世代プログラミング20の極意

// 変数の宣言
val immutableVariable = "これは変更できない変数です"
var mutableVariable = "これは変更可能な変数です"

// 関数の定義
fun greet(name: String): String {
    return "こんにちは、$name さん！"
}

// メイン関数
fun main() {
    println(greet("太郎"))
    mutableVariable = "値を変更しました"
    println(mutableVariable)
}

// Nullを許容する変数
var nullableString: String? = "これはnull可能な文字列です"
nullableString = null // OK

// Nullを許容しない変数
var nonNullString: String = "これはnullにできない文字列です"
// nonNullString = null // コンパイルエラー

// 安全呼び出し演算子
println(nullableString?.length)

// エルビス演算子
val length = nullableString?.length ?: 0

// 非null表明演算子（!!）
val forcedLength = nullableString!!.length // 注意: nullの場合は例外が発生します

fun main() {
    println("Length: $length")
    println("Forced Length: $forcedLength")
}

// 通常の関数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 単一式関数
fun multiply(a: Int, b: Int) = a * b

// 高階関数
fun operation(a: Int, b: Int, func: (Int, Int) -> Int): Int {
    return func(a, b)
}

// ラムダ式
val subtract = { a: Int, b: Int -> a - b }

fun main() {
    println("加算: ${add(5, 3)}")
    println("乗算: ${multiply(4, 2)}")
    
    // 高階関数の使用
    println("高階関数（加算）: ${operation(10, 5, ::add)}")
    println("高階関数（ラムダ式による減算）: ${operation(10, 5, subtract)}")
    
    // インラインのラムダ式
    val result = operation(10, 5) { a, b -> a / b }
    println("高階関数（インラインラムダ式による除算）: $result")
}

// 基本的なクラス
class Person(val name: String, var age: Int) {
    fun introduce() = "私の名前は$name、$age歳です。"
}

// データクラス
data class Book(val title: String, val author: String, val year: Int)

// オブジェクト宣言（シングルトン）
object DatabaseConfig {
    const val URL = "jdbc:mysql://localhost/mydb"
    const val USERNAME = "user"
    const val PASSWORD = "password"
}

// コンパニオンオブジェクト
class MathOperations {
    companion object {
        fun add(a: Int, b: Int) = a + b
        fun subtract(a: Int, b: Int) = a - b
    }
}

fun main() {
    val person = Person("山田太郎", 30)
    println(person.introduce())

    val book = Book("Kotlinプログラミング入門", "鈴木一郎", 2023)
    println("書籍情報: $book")

    println("データベースURL: ${DatabaseConfig.URL}")

    println("5 + 3 = ${MathOperations.add(5, 3)}")
}

// 基本クラス
open class Animal(val name: String) {
    open fun makeSound() {
        println("動物が鳴いています")
    }
}

// 継承
class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("ワンワン！")
    }
}

// インターフェース
interface Flyable {
    fun fly()
}

// 複数のインターフェースを実装
class Bird(name: String) : Animal(name), Flyable {
    override fun makeSound() {
        println("チュンチュン！")
    }

    override fun fly() {
        println("鳥が飛んでいます")
    }
}

// 抽象クラス
abstract class Shape {
    abstract fun area(): Double
}

class Circle(private val radius: Double) : Shape() {
    override fun area(): Double = Math.PI * radius * radius
}

fun main() {
    val dog = Dog("ポチ")
    dog.makeSound()

    val bird = Bird("ピヨ")
    bird.makeSound()
    bird.fly()

    val circle = Circle(5.0)
    println("円の面積: ${circle.area()}")
}

fun main() {
    // リスト
    val numbers = listOf(1, 2, 3, 4, 5)
    println("Numbers: $numbers")

    // ミュータブルリスト
    val mutableNumbers = mutableListOf(1, 2, 3)
    mutableNumbers.add(4)
    println("Mutable Numbers: $mutableNumbers")

    // セット
    val uniqueNumbers = setOf(1, 2, 2, 3, 4, 4, 5)
    println("Unique Numbers: $uniqueNumbers")

    // マップ
    val ages = mapOf("Alice" to 25, "Bob" to 30, "Charlie" to 35)
    println("Ages: $ages")

    // ジェネリクス
    val stringList = listOf("apple", "banana", "cherry")
    val intList = listOf(1, 2, 3)
    
    println("First string: ${getFirstElement(stringList)}")
    println("First number: ${getFirstElement(intList)}")

    // コレクション操作
    val doubledNumbers = numbers.map { it * 2 }
    println("Doubled Numbers: $doubledNumbers")

    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even Numbers: $evenNumbers")

    val sum = numbers.reduce { acc, i -> acc + i }
    println("Sum of Numbers: $sum")
}

// ジェネリック関数
fun <T> getFirstElement(list: List<T>): T? {
    return list.firstOrNull()
}

// 文字列に対する拡張関数
fun String.isPalindrome(): Boolean {
    return this.toLowerCase().replace(Regex("[^a-zA-Z0-9]"), "") ==
           this.toLowerCase().replace(Regex("[^a-zA-Z0-9]"), "").reversed()
}

// Intに対する拡張関数
fun Int.isEven(): Boolean = this % 2 == 0

// Listに対する拡張関数
fun <T> List<T>.secondOrNull(): T? = if (this.size >= 2) this[1] else null

// 拡張プロパティ
val String.lastChar: Char
    get() = this.last()

class Circle(val radius: Double) {
    // 拡張プロパティ
    val area: Double
        get() = Math.PI * radius * radius
}

fun main() {
    // 拡張関数の使用
    println("level".isPalindrome())  // true
    println("hello".isPalindrome())  // false

    println(4.isEven())  // true
    println(7.isEven())

    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers.secondOrNull())  // 2

    // 拡張プロパティの使用
    println("Kotlin".lastChar)  // n

    val circle = Circle(5.0)
    println("円の面積: ${circle.area}")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("メイン関数開始")

    // 並行実行
    val job1 = launch {
        delay(1000L)
        println("ジョブ1完了")
    }

    val job2 = launch {
        delay(800L)
        println("ジョブ2完了")
    }

    // 結果を返す非同期処理
    val deferred = async {
        delay(1500L)
        "非同期処理の結果"
    }

    // ジョブの完了を待つ
    job1.join()
    job2.join()

    // 結果を取得
    val result = deferred.await()
    println("非同期処理の結果: $result")

    println("メイン関数終了")
}

// 非同期関数
suspend fun fetchUserData(): String {
    delay(1000L)  // ネットワーク遅延をシミュレート
    return "ユーザーデータ"
}

// エラーハンドリング
suspend fun fetchDataWithErrorHandling() {
    try {
        withContext(Dispatchers.IO) {
            throw Exception("ネットワークエラー")
        }
    } catch (e: Exception) {
        println("エラーが発生しました: ${e.message}")
    }
}

// HTML DSLの例
class Tag(val name: String) {
    val children = mutableListOf<Tag>()
    val attributes = mutableMapOf<String, String>()

    fun attribute(name: String, value: String) {
        attributes[name] = value
    }

    override fun toString(): String {
        val attributeString = attributes.map { "${it.key}=\"${it.value}\"" }.joinToString(" ")
        val openTag = if (attributeString.isEmpty()) "<$name>" else "<$name $attributeString>"
        val closeTag = "</$name>"
        val childrenString = children.joinToString("")
        return "$openTag$childrenString$closeTag"
    }
}

fun tag(name: String, init: Tag.() -> Unit): Tag {
    val tag = Tag(name)
    tag.init()
    return tag
}

// DSLの使用例
fun html(init: Tag.() -> Unit) = tag("html", init)
fun body(init: Tag.() -> Unit) = tag("body", init)
fun h1(init: Tag.() -> Unit) = tag("h1", init)
fun p(init: Tag.() -> Unit) = tag("p", init)

fun main() {
    val result = html {
        attribute("lang", "ja")
        body {
            h1 {
                +"Kotlinのドメイン特化言語"
            }
            p {
                +"これはKotlinのDSLの例です。"
            }
        }
    }

    println(result)
}

// 文字列を子要素として追加するための演算子オーバーロード
operator fun Tag.unaryPlus(text: String) {
    children.add(Tag("text").apply { children.add(Tag(text)) })
}

import kotlin.properties.Delegates
import kotlin.reflect.KProperty

// カスタム委譲
class StringDelegate {
    private var value: String = ""

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("${property.name}の値を取得: $value")
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
        println("${property.name}の値を設定: $newValue")
        value = newValue
    }
}

// 遅延初期化
class LazyExample {
    val heavyComputation: String by lazy {
        println("重い計算を実行中...")
        Thread.sleep(1000) // 重い処理をシミュレート
        "計算結果"
    }
}

// 監視可能プロパティ
class User {
    var name: String by Delegates.observable("") { prop, old, new ->
        println("${prop.name}が$oldから$newに変更されました")
    }
}

// マップへの委譲
class Configuration(map: Map<String, Any?>) {
    val host: String by map
    val port: Int by map
}

fun main() {
    // カスタム委譲の使用
    var message: String by StringDelegate()
    message = "Hello, Kotlin!"
    println(message)

    // 遅延初期化の使用
    val lazy = LazyExample()
    println("LazyExampleのインスタンスを作成しました")
    println(lazy.heavyComputation)
    println(lazy.heavyComputation) // 2回目は計算されない

    // 監視可能プロパティの使用
    val user = User()
    user.name = "Alice"
    user.name = "Bob"

    // マップへの委譲の使用
    val config = Configuration(mapOf(
        "host" to "localhost",
        "port" to 8080
    ))
    println("Host: ${config.host}, Port: ${config.port}")
}

// シールドクラス
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handleResult(result: Result) = when (result) {
    is Result.Success -> println("成功: ${result.data}")
    is Result.Error -> println("エラー: ${result.message}")
    Result.Loading -> println("読み込み中...")
}

// 列挙型
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF);

    fun containsRed() = (rgb and 0xFF0000 != 0)
}

// 列挙型とwhen式の組み合わせ
fun getColorName(color: Color) = when (color) {
    Color.RED -> "赤"
    Color.GREEN -> "緑"
    Color.BLUE -> "青"
}

fun main() {
    // シールドクラスの使用
    val success: Result = Result.Success("データ取得成功")
    val error: Result = Result.Error("ネットワークエラー")
    val loading: Result = Result.Loading

    handleResult(success)
    handleResult(error)
    handleResult(loading)

    // 列挙型の使用
    val red = Color.RED
    println("赤の RGB 値: ${red.rgb}")
    println("赤は赤成分を含むか: ${red.containsRed()}")

    // 列挙型とwhen式
    Color.values().forEach { color ->
        println("${getColorName(color)}の RGB 値: ${color.rgb}")
    }
}

// インライン関数
inline fun measureTimeMillis(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

// リファイファイド型パラメータを持つインライン関数
inline fun <reified T> isInstanceOf(value: Any): Boolean {
    return value is T
}

// 非ローカルリターン
inline fun forEach(items: List<Int>, action: (Int) -> Unit) {
    for (item in items) {
        action(item)
    }
}

fun main() {
    // インライン関数の使用
    val time = measureTimeMillis {
        Thread.sleep(1000)
        println("1秒経過しました")
    }
    println("実行時間: $time ミリ秒")

    // リファイファイド型パラメータの使用
    println(isInstanceOf<String>("Kotlin"))  // true
    println(isInstanceOf<Int>("Kotlin"))     // false

    // 非ローカルリターンの例
    val numbers = listOf(1, 2, 3, 4, 5)
    forEach(numbers) {
        if (it == 3) return@forEach // ラベル付きリターン
        println(it)
    }

    println("forEachの後")

    // インライン関数を使用しない場合の非ローカルリターン（コンパイルエラー）
    // numbers.forEach {
    //     if (it == 3) return // エラー：非ローカルリターンは許可されていません
    //     println(it)
    // }
}

data class Complex(val real: Double, val imag: Double) {
    // 加算
    operator fun plus(other: Complex): Complex {
        return Complex(real + other.real, imag + other.imag)
    }

    // 減算
    operator fun minus(other: Complex): Complex {
        return Complex(real - other.real, imag - other.imag)
    }

    // 乗算
    operator fun times(other: Complex): Complex {
        val newReal = real * other.real - imag * other.imag
        val newImag = real * other.imag + imag * other.real
        return Complex(newReal, newImag)
    }

    // 単項マイナス
    operator fun unaryMinus(): Complex {
        return Complex(-real, -imag)
    }

    // インデックスアクセス
    operator fun get(index: Int): Double {
        return when(index) {
            0 -> real
            1 -> imag
            else -> throw IndexOutOfBoundsException()
        }
    }

    // 文字列表現
    override fun toString(): String {
        return if (imag >= 0) "$real + ${imag}i" else "$real - ${-imag}i"
    }
}

// 拡張関数としてのオペレータオーバーロード
operator fun Double.times(complex: Complex): Complex {
    return Complex(this * complex.real, this * complex.imag)
}

fun main() {
    val c1 = Complex(3.0, 4.0)
    val c2 = Complex(1.0, 2.0)

    println("c1 = $c1")
    println("c2 = $c2")

    // 加算
    println("c1 + c2 = ${c1 + c2}")

    // 減算
    println("c1 - c2 = ${c1 - c2}")

    // 乗算
    println("c1 * c2 = ${c1 * c2}")

    // 単項マイナス
    println("-c1 = ${-c1}")

    // インデックスアクセス
    println("c1[0] = ${c1[0]}, c1[1] = ${c1[1]}")

    // スカラー倍
    println("2.0 * c1 = ${2.0 * c1}")
}

// 型エイリアス
typealias StringMap = Map<String, String>
typealias IntPredicate = (Int) -> Boolean

// ジェネリック型エイリアス
typealias MyList<T> = List<T>

// 関数型のエイリアス
typealias Operation<T> = (T, T) -> T

// 型プロジェクション
class Box<out T>(val value: T)

// 変位指定のないジェネリッククラス
class MutableBox<T>(var value: T)

fun main() {
    // 型エイリアスの使用
    val map: StringMap = mapOf("key" to "value")
    println("StringMap: $map")

    val isEven: IntPredicate = { it % 2 == 0 }
    println("Is 4 even? ${isEven(4)}")

    val numbers: MyList<Int> = listOf(1, 2, 3)
    println("MyList: $numbers")

    val add: Operation<Int> = { a, b -> a + b }
    println("2 + 3 = ${add(2, 3)}")

    // 型プロジェクションの使用
    val boxOfString: Box<String> = Box("Hello")
    val boxOfAny: Box<Any> = boxOfString // OK、Box<out T>は共変
    println("Box of Any: ${boxOfAny.value}")

    // スター投影
    val boxes: List<Box<*>> = listOf(Box("String"), Box(123))
    for (box in boxes) {
        println("Box contains: ${box.value}")
    }

    // 型プロジェクションの制限
    val mutableBoxOfString: MutableBox<String> = MutableBox("Hello")
    // val mutableBoxOfAny: MutableBox<Any> = mutableBoxOfString // コンパイルエラー

    // 使用サイト差異
    fun copyBox(from: MutableBox<out Any>, to: MutableBox<in String>) {
        to.value = from.value.toString()
    }

    val fromBox = MutableBox(123)
    val toBox = MutableBox("Initial")
    copyBox(fromBox, toBox)
    println("Copied value: ${toBox.value}")
}

// インラインクラスの定義
@JvmInline
value class Meters(val value: Double) {
    fun toKilometers(): Kilometers = Kilometers(value / 1000)

    operator fun plus(other: Meters): Meters {
        return Meters(value + other.value)
    }
}

@JvmInline
value class Kilometers(val value: Double) {
    fun toMeters(): Meters = Meters(value * 1000)
}

// インラインクラスを使用する関数
fun walkDistance(distance: Meters) {
    println("${distance.value}メートル歩きました")
}

// ジェネリック型パラメータを持つインラインクラス
@JvmInline
value class Box<T>(val value: T)

fun main() {
    val distance1 = Meters(100.0)
    val distance2 = Meters(50.0)

    // インラインクラスの演算
    val totalDistance = distance1 + distance2
    println("合計距離: ${totalDistance.value}メートル")

    // 単位変換
    val kilometers = totalDistance.toKilometers()
    println("キロメートルに変換: ${kilometers.value}km")

    // 関数での使用
    walkDistance(Meters(200.0))

    // コンパイル時の型チェック
    // walkDistance(Kilometers(1.0)) // コンパイルエラー

    // ジェネリックインラインクラスの使用
    val boxedString = Box("Hello, Kotlin!")
    val boxedInt = Box(42)

    println("Boxed String: ${boxedString.value}")
    println("Boxed Int: ${boxedInt.value}")
}

// 高階関数
fun <T, R> List<T>.mapWithIndex(transform: (Int, T) -> R): List<R> {
    return mapIndexed { index, item -> transform(index, item) }
}

// カリー化
fun add(x: Int) = { y: Int -> x + y }

// 部分適用
fun logger(tag: String) = { message: String -> println("[$tag] $message") }

// 関数合成
infix fun <A, B, C> ((A) -> B).andThen(g: (B) -> C): (A) -> C {
    return { x -> g(this(x)) }
}

// モナド的な操作（Optionalの例）
sealed class Optional<out T> {
    object None : Optional<Nothing>()
    data class Some<T>(val value: T) : Optional<T>()

    fun <R> map(transform: (T) -> R): Optional<R> = when (this) {
        is None -> None
        is Some -> Some(transform(value))
    }

    fun <R> flatMap(transform: (T) -> Optional<R>): Optional<R> = when (this) {
        is None -> None
        is Some -> transform(value)
    }
}

fun main() {
    // 高階関数の使用
    val numbers = listOf(1, 2, 3, 4, 5)
    val result = numbers.mapWithIndex { index, value -> "Index: $index, Value: $value" }
    println("MapWithIndex result: $result")

    // カリー化と部分適用
    val add5 = add(5)
    println("5 + 3 = ${add5(3)}")

    val logError = logger("ERROR")
    logError("Something went wrong")

    // 関数合成
    val double = { x: Int -> x * 2 }
    val addOne = { x: Int -> x + 1 }
    val doubleAndAddOne = double andThen addOne
    println("Double and add one to 5: ${doubleAndAddOne(5)}")

    // モナド的な操作
    val optionalValue: Optional<Int> = Optional.Some(10)
    val mappedValue = optionalValue
        .map { it * 2 }
        .flatMap { Optional.Some(it + 1) }
    
    when (mappedValue) {
        is Optional.Some -> println("Result: ${mappedValue.value}")
        is Optional.None -> println("No value")
    }
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlin.system.measureTimeMillis

// 構造化並行性
suspend fun doWork1(): Int {
    delay(1000)
    return 10
}

suspend fun doWork2(): Int {
    delay(1000)
    return 20
}

// フロー
fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}

// エラーハンドリング
suspend fun riskyOperation(): Int {
    delay(500)
    throw RuntimeException("Something went wrong")
}

// コンテキストの切り替え
suspend fun printThreadName(name: String) {
    println("$name: ${Thread.currentThread().name}")
}

fun main() = runBlocking {
    // 構造化並行性
    val time = measureTimeMillis {
        val result1 = async { doWork1() }
        val result2 = async { doWork2() }
        println("結果の合計: ${result1.await() + result2.await()}")
    }
    println("処理時間: $time ms")

    // フロー
    simpleFlow().collect { value ->
        println("Received: $value")
    }

    // エラーハンドリング
    try {
        supervisorScope {
            launch { riskyOperation() }
            launch { println("この処理は実行されます") }
        }
    } catch (e: Exception) {
        println("エラーをキャッチしました: ${e.message}")
    }

    // コンテキストの切り替え
    launch(Dispatchers.Default) {
        printThreadName("Default")
        withContext(Dispatchers.IO) {
            printThreadName("IO")
        }
    }

    // タイムアウト処理
    withTimeoutOrNull(1500) {
        repeat(3) {
            delay(1000)
            println("まだ実行中...")
        }
    }
    println("タイムアウトしました")

    // キャンセレーション
    val job = launch {
        try {
            repeat(1000) { i ->
                delay(500)
                println("処理 $i ...")
            }
        } finally {
            println("キャンセル処理")
        }
    }
    delay(1300)
    job.cancelAndJoin()
    println("メイン処理終了")
}

@DslMarker
annotation class HtmlDsl

@HtmlDsl
class Tag(val name: String) {
    val children = mutableListOf<Any>()
    val attributes = mutableMapOf<String, String>()

    operator fun String.unaryPlus() {
        children.add(this)
    }

    fun attribute(name: String, value: String) {
        attributes[name] = value
    }

    fun <T : Tag> initTag(tag: T, init: T.() -> Unit): T {
        tag.init()
        children.add(tag)
        return tag
    }

    override fun toString(): String {
        val attributesString = attributes.entries.joinToString(" ") { "${it.key}=\"${it.value}\"" }
        val openTag = if (attributesString.isEmpty()) "<$name>" else "<$name $attributesString>"
        val closeTag = "</$name>"
        val childrenString = children.joinToString("")
        return "$openTag$childrenString$closeTag"
    }
}

@HtmlDsl
class HTML : Tag("html")

@HtmlDsl
class Head : Tag("head")

@HtmlDsl
class Body : Tag("body")

@HtmlDsl
fun html(init: HTML.() -> Unit): HTML = HTML().apply(init)

@HtmlDsl
fun HTML.head(init: Head.() -> Unit) = initTag(Head(), init)

@HtmlDsl
fun HTML.body(init: Body.() -> Unit) = initTag(Body(), init)

@HtmlDsl
fun Tag.h1(init: Tag.() -> Unit) = initTag(Tag("h1"), init)

@HtmlDsl
fun Tag.p(init: Tag.() -> Unit) = initTag(Tag("p"), init)

@HtmlDsl
fun Tag.a(href: String, init: Tag.() -> Unit) {
    val tag = initTag(Tag("a"), init)
    tag.attribute("href", href)
}

fun main() {
    val result = html {
        head {
            +"<title>Kotlin DSL Example</title>"
        }
        body {
            h1 {
                +"Welcome to Kotlin DSL"
            }
            p {
                +"This is a paragraph."
            }
            p {
                +"Here's a "
                a(href = "https://kotlinlang.org") {
                    +"link to Kotlin"
                }
            }
        }
    }

    println(result)
}

import kotlin.reflect.KClass

// カスタム注釈の定義
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Table(val name: String)

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Column(val name: String = "")

// 注釈付きのデータクラス
@Table("users")
data class User(
    @Column("id") val id: Int,
    @Column val name: String,
    @Column("email_address") val email: String
)

// 注釈を処理するユーティリティ関数
fun <T : Any> createTableQuery(clazz: KClass<T>): String {
    val table = clazz.annotations.filterIsInstance<Table>().firstOrNull()
        ?: throw IllegalArgumentException("Class ${clazz.simpleName} is not annotated with @Table")

    val columns = clazz.members
        .filterIsInstance<kotlin.reflect.KProperty1<T, *>>()
        .mapNotNull { prop ->
            prop.annotations.filterIsInstance<Column>().firstOrNull()?.let { column ->
                val columnName = if (column.name.isNotEmpty()) column.name else prop.name
                "$columnName ${getColumnType(prop.returnType.classifier)}"
            }
        }

    return "CREATE TABLE ${table.name} (${columns.joinToString(", ")})"
}

// プロパティの型からSQLの型を推論する関数
fun getColumnType(type: KClassifier?): String = when (type) {
    Int::class -> "INTEGER"
    String::class -> "TEXT"
    Boolean::class -> "BOOLEAN"
    else -> "TEXT"
}

fun main() {
    val query = createTableQuery(User::class)
    println(query)

    // リフレクションを使用してプロパティにアクセス
    val user = User(1, "John Doe", "john@example.com")
    User::class.members.forEach { member ->
        if (member is KProperty1<*, *>) {
            println("${member.name}: ${member.get(user)}")
        }
    }
}

// シングルトンパターン
object DatabaseConnection {
    init {
        println("データベース接続を初期化しています...")
    }

    fun connect() = println("データベースに接続しました")
}

// ファクトリーパターン
interface Animal {
    fun speak()
}

class Dog : Animal {
    override fun speak() = println("ワンワン！")
}

class Cat : Animal {
    override fun speak() = println("ニャー！")
}

object AnimalFactory {
    fun createAnimal(type: String): Animal = when (type.toLowerCase()) {
        "dog" -> Dog()
        "cat" -> Cat()
        else -> throw IllegalArgumentException("Unknown animal type")
    }
}

// オブザーバーパターン
interface Observer {
    fun update(message: String)
}

class Subject {
    private val observers = mutableListOf<Observer>()

    fun addObserver(observer: Observer) = observers.add(observer)
    fun removeObserver(observer: Observer) = observers.remove(observer)
    fun notifyObservers(message: String) = observers.forEach { it.update(message) }
}

// ストラテジーパターン
interface PaymentStrategy {
    fun pay(amount: Int)
}

class CreditCardPayment(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Int) = println("$amount円をクレジットカード$cardNumberで支払いました")
}

class PayPalPayment(private val email: String) : PaymentStrategy {
    override fun pay(amount: Int) = println("$amount円をPayPal($email)で支払いました")
}

class ShoppingCart(private var paymentStrategy: PaymentStrategy) {
    fun checkout(amount: Int) = paymentStrategy.pay(amount)
    fun setPaymentStrategy(strategy: PaymentStrategy) {
        paymentStrategy = strategy
    }
}

// デコレーターパターン
interface Coffee {
    fun getCost(): Double
    fun getDescription(): String
}

class SimpleCoffee : Coffee {
    override fun getCost() = 3.0
    override fun getDescription() = "シンプルコーヒー"
}

class MilkDecorator(private val coffee: Coffee) : Coffee {
    override fun getCost() = coffee.getCost() + 0.5
    override fun getDescription() = "${coffee.getDescription()}、ミルク追加"
}

class SugarDecorator(private val coffee: Coffee) : Coffee {
    override fun getCost() = coffee.getCost() + 0.2
    override fun getDescription() = "${coffee.getDescription()}、砂糖追加"
}

fun main() {
    // シングルトンの使用
    DatabaseConnection.connect()

    // ファクトリーパターンの使用
    val dog = AnimalFactory.createAnimal("dog")
    dog.speak()

    // オブザーバーパターンの使用
    val subject = Subject()
    val observer1 = object : Observer {
        override fun update(message: String) = println("オブザーバー1: $message")
    }
    val observer2 = object : Observer {
        override fun update(message: String) = println("オブザーバー2: $message")
    }

    subject.addObserver(observer1)
    subject.addObserver(observer2)
    subject.notifyObservers("重要なメッセージです！")

    // ストラテジーパターンの使用
    val cart = ShoppingCart(CreditCardPayment("1234-5678-9012-3456"))
    cart.checkout(100)
    cart.setPaymentStrategy(PayPalPayment("user@example.com"))
    cart.checkout(200)

    // デコレーターパターンの使用
    var coffee: Coffee = SimpleCoffee()
    println("${coffee.getDescription()}: ${coffee.getCost()}円")

    coffee = MilkDecorator(coffee)
    println("${coffee.getDescription()}: ${coffee.getCost()}円")

    coffee = SugarDecorator(coffee)
    println("${coffee.getDescription()}: ${coffee.getCost()}円")
}