Kotlin: Kotlinの変数と型システム

// Java: verbose and error-prone
if (obj instanceof Order) {
    Order order = (Order) obj;  // Must cast again
    System.out.println(order.getId());
}

// Kotlin: smart cast eliminates the cast
if (obj is Order) {
    println(obj.id)  // No cast needed!
}

val intValue: Int = 42          // 32-bit
val longValue: Long = 42L       // 64-bit
val doubleValue: Double = 3.14  // 64-bit IEEE 754
val floatValue: Float = 3.14f   // 32-bit IEEE 754

// Underscore for readability
val million = 1_000_000
val creditCard = 1234_5678_9012_3456L
val bytes = 0b11010010_01101001

val bool: Boolean = true
val char: Char = 'A'
val str: String = "OrderProcessor"

// Character is NOT a number in Kotlin
// val code: Int = 'A'  // ERROR
val code: Int = 'A'.code  // OK: 65
val charFromCode: Char = 65.toChar()  // OK: 'A'

fun process(input: Any) {
    // After 'is' check, compiler smart casts
    if (input is String) {
        println(input.length)  // Smart cast to String
    }

    // After '!is' check
    if (input !is String) return
    println(input.length)  // Smart cast to String
}

// Smart cast with when
fun describe(obj: Any): String = when (obj) {
    is String -> "String: ${obj.length} chars"     // Smart cast
    is Int -> "Int: ${obj.dec()}"                   // Smart cast
    is List<*> -> "List: ${obj.size} items"         // Smart cast
    else -> "Unknown"
}

// WARNING: smart cast may not work with var or custom getters
var obj: Any = "Hello"
if (obj is String) {
    // obj could be changed between check and use
    // println(obj.length)  // WARNING in some cases
}

// Safe approach: use local val
val safeObj = obj
if (safeObj is String) {
    println(safeObj.length)  // OK - guaranteed stable
}

val longVal: Long = 42L
val intVal: Int = longVal.toInt()    // Explicit narrowing
val doubleVal: Double = 3.99
val intFromDouble: Int = doubleVal.toInt()  // Truncates: 3

// String to number
val parsed: Int = "42".toInt()
val parsedDouble: Double = "3.14".toDouble()

// Number to string
val strVal: String = 42.toString()

// This would silently lose data - Kotlin prevents it
val longValue: Long = 2_147_483_648L  // Exceeds Int.MAX_VALUE
// val intValue: Int = longValue  // COMPILE ERROR

// Must be explicit about potential data loss
val intValue: Int = longValue.toInt()  // OK but may overflow

// Any is the root of the Kotlin type hierarchy (like Object in Java)
val obj: Any = "Hello"
val obj2: Any = 42
val obj3: Any = Order("ORD-001", 299.99, "CONFIRMED")

// Any has only 3 methods: equals, hashCode, toString
// Use Any? for nullable root type

// Unit is like void in Java, but it's a real type
fun logOrder(order: Order): Unit {  // Unit return is optional
    println("Processing ${order.id}")
}

fun logOrder2(order: Order) {  // Equivalent - Unit inferred
    println("Processing ${order.id}")
}

// Unit is a singleton - can be used as a value
val unitValue: Unit = Unit

// Nothing means "this code never returns"
fun fail(message: String): Nothing {
    throw IllegalStateException(message)
}

// Useful for Elvis operator with exceptions
val customer = order.customer ?: fail("Customer required")

// Infinite loop also returns Nothing
fun infiniteLoop(): Nothing {
    while (true) { /* never returns */ }
}

// Simplify complex type signatures
typealias OrderMap = Map<String, List<Order>>
typealias OrderProcessor = (List<Order>) -> List<String>
typealias USD = Double

// Usage
val ordersByCustomer: OrderMap = mapOf(
    "Alice" to listOf(Order("ORD-001", 299.99, "CONFIRMED"))
)

typealias Predicate<T> = (T) -> Boolean
val isHighValue: Predicate<Order> = { it.total > 10_000 }

// typealias does NOT create new types - just aliases
val map: OrderMap = ordersByCustomer  // Same type

// ============================================
// OrderProcessor - Type-Safe Event Processing
// Feature: Process order events with smart cast
// ============================================

typealias OrderId = String
typealias USD = Double

sealed class OrderEvent {
    data class Created(val orderId: OrderId, val total: USD) : OrderEvent()
    data class Paid(val orderId: OrderId, val amount: USD) : OrderEvent()
    data class Shipped(val orderId: OrderId, val trackingCode: String) : OrderEvent()
    data class Cancelled(val orderId: OrderId, val reason: String) : OrderEvent()
}

fun handleEvent(event: OrderEvent): String = when (event) {
    is OrderEvent.Created -> {
        // Smart cast: event.orderId and event.total available
        val threshold = 10_000
        val priority = if (event.total > threshold) "VIP" else "STANDARD"
        "Order ${event.orderId} created (\$${event.total} USD) -> $priority"
    }
    is OrderEvent.Paid -> {
        val tax = event.amount * 0.08
        "Order ${event.orderId} paid: \$${event.amount} USD (tax: \$$tax USD)"
    }
    is OrderEvent.Shipped ->
        "Order ${event.orderId} shipped: ${event.trackingCode}"
    is OrderEvent.Cancelled ->
        "Order ${event.orderId} cancelled: ${event.reason}"
}

fun main() {
    val events: List<OrderEvent> = listOf(
        OrderEvent.Created("ORD-001", 299.99),
        OrderEvent.Created("ORD-002", 15_000.00),
        OrderEvent.Paid("ORD-001", 299.99),
        OrderEvent.Shipped("ORD-001", "TRK-ABC123"),
        OrderEvent.Cancelled("ORD-003", "Customer request")
    )

    events.forEach { event ->
        val result = handleEvent(event)
        println(result)
    }

    // Type check with smart cast
    val anyEvent: Any = events[0]
    if (anyEvent is OrderEvent.Created) {
        println("\nSmart cast works: ${anyEvent.orderId} costs \$${anyEvent.total} USD")
    }
}

Order ORD-001 created ($299.99 USD) -> STANDARD
Order ORD-002 created ($15000.0 USD) -> VIP
Order ORD-001 paid: $299.99 USD (tax: $23.999200000000002 USD)
Order ORD-001 shipped: TRK-ABC123
Order ORD-003 cancelled: Customer request

Smart cast works: ORD-001 costs $299.99 USD