상속과 인터페이스 — open, override, 그리고 다중 상속 문제 해결

// 기본적으로 final — 상속 불가
class Animal

// class Dog : Animal()   // 컴파일 에러!

// open으로 상속 허용
open class Animal2 {
    open fun speak() = "..."          // 오버라이드 허용
    fun breathe() = "숨 쉬기"         // 오버라이드 불가
}

class Dog : Animal2() {
    override fun speak() = "멍멍"     // OK
    // override fun breathe() = "..."  // 컴파일 에러!
}

open class Shape(val name: String) {
    open val area: Double = 0.0

    open fun draw() {
        println("$name 그리기")
    }
}

class Circle(val radius: Double) : Shape("원") {
    // 프로퍼티도 오버라이드 가능
    override val area: Double
        get() = Math.PI * radius * radius

    override fun draw() {
        println("반지름 $radius 인 원 그리기")
    }
}

open class Parent {
    open fun method() { }          // 오버라이드 가능
    fun finalMethod() { }          // 오버라이드 불가
    open val property: Int = 0     // 오버라이드 가능
}

open class Child : Parent() {
    override fun method() { }      // 오버라이드 — 여전히 open
    final override fun method() { }  // 오버라이드하되, 하위에서는 금지

    // val을 var로 오버라이드 가능 (getter에 setter 추가)
    override var property: Int = 0
    // 반대는 불가 — var를 val로 오버라이드할 수 없음
}

// 상위 클래스에 주 생성자가 있으면 바로 호출
open class Person(val name: String)
class Student(name: String, val grade: Int) : Person(name)

// 상위 클래스에 주 생성자가 없으면 보조 생성자에서 super 호출
open class View {
    constructor(context: Context)
    constructor(context: Context, attrs: AttributeSet)
}

class CustomView : View {
    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet) : super(context, attrs)
}

interface Clickable {
    // 추상 메서드
    fun click()

    // default 구현이 있는 메서드 (자바처럼 default 키워드 불필요)
    fun showOff() = println("클릭 가능!")
}

interface Focusable {
    fun focus()
    fun showOff() = println("포커스 가능!")
}

class Button : Clickable, Focusable {
    override fun click() = println("버튼 클릭")
    override fun focus() = println("버튼 포커스")

    // showOff()가 두 인터페이스에 모두 있으므로 반드시 오버라이드 필요
    override fun showOff() {
        super<Clickable>.showOff()     // Clickable의 구현 호출
        super<Focusable>.showOff()     // Focusable의 구현 호출
    }
}

interface A {
    fun greet() = println("A의 인사")
}

interface B {
    fun greet() = println("B의 인사")
}

class C : A, B {
    // 반드시 오버라이드 — 어떤 구현을 쓸지 명시해야 함
    override fun greet() {
        super<A>.greet()   // "A의 인사"
    }
}

interface Named {
    val name: String                    // 추상 프로퍼티 — 구현 클래스에서 제공

    val greeting: String                // backing field 없는 computed 프로퍼티
        get() = "안녕, $name"

    // val state: String = "기본값"     // 컴파일 에러! 인터페이스는 backing field 불가
}

class User(override val name: String) : Named
// user.greeting → "안녕, 코틀린"

abstract class Animal(val name: String) {
    // 상태를 가질 수 있음 (backing field)
    var energy: Int = 100

    // 추상 메서드 — open 불필요 (기본이 open)
    abstract fun speak(): String

    // 일반 메서드
    fun eat() {
        energy += 10
        println("$name 이(가) 먹이를 먹었다. 에너지: $energy")
    }
}

class Cat(name: String) : Animal(name) {
    override fun speak() = "야옹"
}

// 인터페이스가 적합한 경우 — 행위의 계약
interface Drawable {
    fun draw()
}

interface Resizable {
    fun resize(factor: Double)
}

// 추상 클래스가 적합한 경우 — 공통 상태 + 템플릿
abstract class Shape(val color: String) {
    var x: Double = 0.0      // 공통 상태
    var y: Double = 0.0

    abstract fun area(): Double

    fun moveTo(newX: Double, newY: Double) {
        x = newX
        y = newY
    }
}

// 둘 다 사용
class Circle(color: String, val radius: Double) : Shape(color), Drawable, Resizable {
    override fun area() = Math.PI * radius * radius
    override fun draw() = println("원 그리기")
    override fun resize(factor: Double) { /* ... */ }
}

open class Parent {
    open val value: Int = 1

    init {
        // 위험! 하위 클래스에서 오버라이드한 프로퍼티가 아직 초기화되지 않았을 수 있음
        println("Parent init: value = $value")
    }
}

class Child : Parent() {
    override val value: Int = 42

    init {
        println("Child init: value = $value")
    }
}

// Child() 출력:
// Parent init: value = 0    ← 예상: 42지만 아직 초기화 안 됨!
// Child init: value = 42

// 과도한 상속 — 유지보수 어려움
open class A
open class B : A()
open class C : B()
open class D : C()  // 상속 체인이 너무 깊음

// 더 나은 접근 — 조합(composition) 사용
class Engine { fun start() { } }
class Car(private val engine: Engine) {
    fun start() = engine.start()
}

interface SoundPlayer {
    fun play()
}

class DefaultSoundPlayer : SoundPlayer {
    override fun play() = println("기본 재생")
}

// 위임 — SoundPlayer 구현을 player에게 맡김
class MusicApp(player: SoundPlayer) : SoundPlayer by player