Kotlin: Kotlinの継承とインターフェース

// Java: override annotation is optional - silent override possible
class SpecialOrder extends Order {
    double calculateTotal() { ... }  // Silently overrides!
}

// Kotlin: override is MANDATORY - compiler catches mistakes
open class Order {
    open fun calculateTotal(): Double = ...
}
class SpecialOrder : Order() {
    override fun calculateTotal(): Double = ...  // Must declare override
}

// Default: class is final (cannot be inherited)
class Order(val id: String)  // Cannot be extended

// Open: explicitly allow inheritance
open class Order(val id: String) {
    // Methods are also final by default
    fun process() { }  // Cannot be overridden

    // Open method: explicitly allow override
    open fun calculateTotal(): Double = 0.0
}

// Abstract: must be inherited, cannot be instantiated
abstract class BaseOrder(val id: String) {
    // Abstract method: must be implemented by subclass
    abstract fun calculateTotal(): Double

    // Concrete method in abstract class
    fun getId(): String = id
}

interface Discountable {
    // Abstract method
    fun discountRate(): Double

    // Default implementation
    fun applyDiscount(total: Double): Double {
        return total * (1.0 - discountRate())
    }
}

interface Trackable {
    val trackingCode: String?  // Abstract property

    fun track(): String = trackingCode?.let { "Tracking: $it" } ?: "Not shipped"
}

// Implement multiple interfaces
class PremiumOrder(
    val id: String,
    val total: Double,
    override val trackingCode: String?
) : Discountable, Trackable {
    override fun discountRate() = 0.15  // 15% discount
}

open class Order(val id: String, var status: String) {
    open fun summary(): String = "Order $id: $status"
}

class BulkOrder(id: String, status: String, val minQuantity: Int) : Order(id, status) {
    // MUST use override keyword
    override fun summary(): String = "Bulk $id: $status (min: $minQuantity)"
}

open class Order {
    open fun process() { }
}

class SpecialOrder : Order() {
    // Prevent further override in subclasses
    final override fun process() { }
}

interface A {
    fun hello() = "A"
}

interface B {
    fun hello() = "B"
}

// Diamond: C inherits hello() from both A and B
class C : A, B {
    // MUST override to resolve conflict
    override fun hello(): String {
        // Explicitly choose which parent's implementation
        return super<A>.hello()  // Choose A's implementation
    }
}

class D : A, B {
    override fun hello(): String {
        // Strategy 1: Pick one parent
        return super<B>.hello()

        // Strategy 2: Combine both
        // return "${super<A>.hello()} + ${super<B>.hello()}"

        // Strategy 3: Custom implementation
        // return "D"
    }
}

// ============================================
// OrderProcessor - Inheritance Hierarchy
// Feature: Order / BulkOrder / PriorityOrder
// ============================================

interface Discountable {
    fun discountRate(): Double
    fun applyDiscount(total: Double): Double = total * (1.0 - discountRate())
}

interface Trackable {
    val trackingCode: String?
    fun track(): String = trackingCode?.let { "Tracking: $it" } ?: "Not shipped yet"
}

open class Order(val id: String, var status: String, val total: Double) {
    init {
        require(total >= 0) { "Total must be non-negative" }
    }

    open fun summary(): String = "Order $id | \$$total USD | $status"
    open fun calculateFinal(): Double = total
}

class BulkOrder(
    id: String,
    status: String,
    total: Double,
    val minQuantity: Int
) : Order(id, status, total), Discountable {

    override fun discountRate() = 0.10  // 10% bulk discount

    override fun calculateFinal(): Double = applyDiscount(total)

    override fun summary(): String =
        "${super.summary()} | Bulk (min: $minQuantity) | Final: \$${calculateFinal()} USD"
}

class PriorityOrder(
    id: String,
    status: String,
    total: Double,
    val priority: String,
    override val trackingCode: String?
) : Order(id, status, total), Discountable, Trackable {

    override fun discountRate() = when (priority) {
        "VIP" -> 0.20
        "GOLD" -> 0.15
        else -> 0.05
    }

    override fun calculateFinal(): Double = applyDiscount(total)

    override fun summary(): String =
        "${super.summary()} | Priority: $priority | ${track()} | Final: \$${calculateFinal()} USD"
}

fun main() {
    val orders = listOf(
        Order("ORD-001", "CONFIRMED", 299.99),
        BulkOrder("ORD-002", "CONFIRMED", 5_000.00, 100),
        PriorityOrder("ORD-003", "SHIPPED", 15_000.00, "VIP", "TRK-XYZ789"),
        PriorityOrder("ORD-004", "PENDING", 2_500.00, "GOLD", null)
    )

    println("=== Order Summary ===")
    orders.forEach { println(it.summary()) }

    val totalSavings = orders
        .filterIsInstance<Discountable>()
        .sumOf { it.applyDiscount((it as Order).total) - (it as Order).calculateFinal() }

    println("\nTotal savings from discounts: \$$totalSavings USD")
}

=== Order Summary ===
Order ORD-001 | $299.99 USD | CONFIRMED
Order ORD-002 | $5000.0 USD | CONFIRMED | Bulk (min: 100) | Final: $4500.0 USD
Order ORD-003 | $15000.0 USD | SHIPPED | Priority: VIP | Tracking: TRK-XYZ789 | Final: $12000.0 USD
Order ORD-004 | $2500.0 USD | PENDING | Priority: GOLD | Not shipped yet | Final: $2125.0 USD

Total savings from discounts: $3475.0 USD