Kotlin: Kotlinのnull安全性を徹底理解

// Java: runtime bomb
String city = order.getCustomer().getAddress().getCity();  // NPE possible!

// Kotlin: compile-time safety
val city: String = order.customer?.address?.city ?: "Unknown"  // Safe!

// Non-null: CANNOT hold null
val orderId: String = "ORD-001"
// orderId = null  // COMPILE ERROR

// Nullable: MUST declare with ?
val customerName: String? = null
customerName = "Alice"  // OK

val name: String? = getInput()
// println(name.length)  // ERROR: nullable receiver

// Must handle null case explicitly
println(name?.length)              // Safe call: Int?
println(name?.length ?: 0)         // Elvis: Int
println(name!!.length)             // Non-null assertion: Int (throws if null)
if (name != null) println(name.length)  // Smart cast: Int

val order: Order? = fetchOrder()

// 1. Safe call ?. - returns null if receiver is null
val id = order?.id  // String?

// 2. Elvis ?: - provide default when null
val total = order?.total ?: 0.0  // Double

// 3. Non-null assertion !! - throw NPE if null
val status = order!!.status  // String (DANGEROUS - use sparingly)

// 4. let chain - execute block only if non-null
order?.let {
    println("Processing ${it.id}")  // 'it' is guaranteed non-null
}

data class Address(val city: String, val country: String)
data class Customer(val name: String, val address: Address?)
data class Order(val id: String, val customer: Customer?)

// Safe chain through multiple nullable references
val order: Order? = fetchOrder()
val city = order?.customer?.address?.city ?: "Unknown"
val country = order?.customer?.address?.country ?: "N/A"

// Nested let can be hard to read
order?.let { o ->
    o.customer?.let { c ->
        c.address?.let { a ->
            println("${a.city}, ${a.country}")
        }
    }
}

// Better: use safe call chain
val addressInfo = order?.customer?.address?.let {
    "${it.city}, ${it.country}"
} ?: "Address unavailable"

// Strategy 1: Default value
val name = customer?.name ?: "Anonymous"

// Strategy 2: Throw exception
val order = findOrder(id) ?: throw OrderNotFoundException(id)

// Strategy 3: Return early
fun process(order: Order?) {
    val confirmed = order ?: return
    // confirmed is smart-cast to non-null Order
    println(confirmed.id)
}

// Strategy 4: requireNotNull for parameter validation
fun createInvoice(orderId: String, customer: Customer?) {
    val cust = requireNotNull(customer) { "Customer is required for invoice" }
    // cust is smart-cast to non-null Customer
}

// Java code - return type unknown nullability
public class JavaOrderService {
    public Order findOrder(String id) {  // Could be null!
        return orderMap.get(id);
    }
}

// Kotlin: platform type - you decide!
val order = javaService.findOrder("ORD-001")

// Option 1: Treat as nullable (safe)
val safeOrder: Order? = javaService.findOrder("ORD-001")

// Option 2: Treat as non-null (risky)
val riskyOrder: Order = javaService.findOrder("ORD-001")  // NPE if null!

// Java with annotations
public class JavaOrderService {
    @Nullable
    public Order findOrder(String id) { return null; }

    @NotNull
    public List<Order> findAll() { return orders; }
}

// Kotlin now knows the nullability
val order: Order? = javaService.findOrder("ORD-001")  // Known nullable
val all: List<Order> = javaService.findAll()           // Known non-null

// ============================================
// OrderProcessor - Null-Safe Operations
// Feature: Safe chains, Elvis strategies, requireNotNull
// ============================================

data class Address(val street: String, val city: String, val country: String)
data class Customer(val name: String, val email: String?, val address: Address?)
data class Order(val id: String, val total: Double, val customer: Customer?, val status: String)

class OrderNotFoundException(id: String) : RuntimeException("Order not found: $id")

// Safe chain helper
fun Order.getCity(): String = customer?.address?.city ?: "Unknown"
fun Order.getCountry(): String = customer?.address?.country ?: "N/A"
fun Order.getDisplayEmail(): String = customer?.email ?: "no-email"

// Elvis strategies
fun findOrderOrFail(id: String, orders: List<Order>): Order =
    orders.find { it.id == id } ?: throw OrderNotFoundException(id)

fun processOrder(order: Order?) {
    val confirmed = order ?: run {
        println("Skipping: null order")
        return
    }
    println("Processing: ${confirmed.id}")
}

fun validateOrder(order: Order): Order {
    requireNotNull(order.customer) { "Customer is required for order ${order.id}" }
    require(order.total > 0) { "Total must be positive" }
    return order
}

fun main() {
    val orders = listOf(
        Order("ORD-001", 299.99, Customer("Alice", "alice@example.com",
            Address("123 Main St", "New York", "US")), "CONFIRMED"),
        Order("ORD-002", 1_500.00, Customer("Bob", null, null), "PENDING"),
        Order("ORD-003", 8_900.00, null, "SHIPPED"),
        Order("ORD-004", 45.50, Customer("Charlie", "charlie@example.com",
            Address("456 Oak Ave", "London", "UK")), "CONFIRMED")
    )

    // Safe chains
    println("=== Order Details ===")
    orders.forEach { order ->
        println("${order.id}: ${order.getCity()}, ${order.getCountry()} | Email: ${order.getDisplayEmail()}")
    }

    // Elvis: find or fail
    println("\n=== Find Orders ===")
    println("ORD-001: ${findOrderOrFail("ORD-001", orders).total} USD")
    try {
        findOrderOrFail("ORD-999", orders)
    } catch (e: OrderNotFoundException) {
        println("Error: ${e.message}")
    }

    // Elvis: early return
    println("\n=== Process Orders ===")
    processOrder(orders[0])  // Processes
    processOrder(null)       // Skips

    // requireNotNull validation
    println("\n=== Validation ===")
    orders.forEach { order ->
        try {
            validateOrder(order)
            println("${order.id}: Valid")
        } catch (e: IllegalArgumentException) {
            println("${order.id}: Invalid - ${e.message}")
        } catch (e: IllegalStateException) {
            println("${order.id}: Invalid - ${e.message}")
        }
    }
}

=== Order Details ===
ORD-001: New York, US | Email: alice@example.com
ORD-002: Unknown, N/A | Email: no-email
ORD-003: Unknown, N/A | Email: no-email
ORD-004: London, UK | Email: charlie@example.com

=== Find Orders ===
ORD-001: 299.99 USD
Error: Order not found: ORD-999

=== Process Orders ===
Processing: ORD-001
Skipping: null order

=== Validation ===
ORD-001: Valid
ORD-002: Valid
ORD-003: Invalid - Customer is required for order ORD-003
ORD-004: Valid