코틀린 Inheritance

Inheritance

코틀린에서 모든 클래스들은 보편적으로 Any라는 클래스를 super class로 갖고있습니다. Any는 super type이 선언되지 않은 클래스의 디폴트 super class입니다.

class Example // implicitly inherits from Any

Any는 equals(), hashCode(), toString() 이렇게 세 가지 메소드를 가지고 있습니다. 그러므로 이러한 메소드는 코틀린 내의 모든 클래스에 정의됩니다.

기본적으로, 코틀린의 클래스는 상속될 수 없는 final입니다. 이러한 클래스가 상속될 수 있게 하기위해서는 클래스 선언부 앞에 open 키워드를 붙여줘야 합니다.

open class Base // Class is open for inheritance

명시적으로 super type을 선언하기 위해서는 클래스 선언부 뒤에 콜론을 붙이고 타입을 적으면 됩니다.

open class Base(p: Int)

class Derived(p: Int): Base(p)

만약 상속받은 클래스가 주 생성자를 가지고 있다면, 기반 클래스는 매개변수를 사용하여 주 생성자에서 초기화 될 수 있어야합니다.

그렇지 않고 주 생성자를 가지고 있지 않다면, 각 보조 생성자는 super키워드를 사용하거나 다른 생성자로 위임하여 기반 클래스를 초기화 해야합니다.

class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

Overriding methods

코틀린은 오버라이드 할 수 있는 멤버 및 오버라이드에 대해 명시적인 수정자(modifier)를 요구합니다.

open class Shape {
    open fun draw() { /*...*/ }
    fun fill() { /*...*/ }
}

class Circle() : Shape() {
    override fun draw() { /*...*/ }
}

override 수정자는 Circle.draw에게 요구됩니다. 만약 override 수정자가 없다면, 컴파일 에러가 발생할 것입니다.
Shape.fill 함수처럼 open키워드가 없다면, 상속받은 클래스에서
override를 사용하던 그렇지 않던, 같은 이름을 갖는 함수를 사용할 수 없습니다. open 수정자는 final 클래스의 멤버에게 사용될 때, 아무런 효과가 없습니다.

override 수정자가 붙은 멤버는 그 자체로 open상태이므로 상속 받은 클래스에서 또 오버라이딩 될 수 있습니다. 만약 이를 막고싶다면, override 앞에 final을 붙이면 됩니다.

open class Rectangle() : Shape() {
    final override fun draw() { /*...*/ }
}

Overriding properties

프로퍼티에 적용되는 오버라이딩 매커니즘은 메소드에 적용되는 것과 동일합니다.
super class에 선언된 프로퍼티는 파생 클래스에서 오버라이딩 되기 위해서 open 키워드가 사용되어야 합니다. 또한 파생클래스에서는 마찬가지로 override 키워드를 사용해야합니다.
프로퍼티는 초기화 구문이나 get메소드를 사용하여 오버라이딩 될 수 있습니다.

open class Shape {
    open val vertexCount: Int = 0
}

class Rectangle : Shape() {
    override val vertexCount = 4
}

val 프로퍼티를 var 프로퍼티로 오버라이딩 할 수 있습니다. 하지만 그 반대의 경우는 불가능합니다. 왜냐하면, val 프로퍼티는 반드시 get 메소드를 가지고 있고 추가적으로 오버라이딩 된 var 프로퍼티에 set메소드를 추가하면 됩니다.

override 키워드를 주 생성자에서 프로퍼티 선언의 일부로 사용할 수도 있습니다.

interface Shape {
    val vertexCount: Int
}

class Rectangle(override val vertexCount: Int = 4) : Shape // Always has 4 vertices

class Polygon : Shape {
    override var vertexCount: Int = 0  // Can be set to any number later
}

Derived class initialization order

파생 클래스의 새로운 인스턴스가 생성되는 동안, 기반 클래스 초기화는 첫번째로 이루어집니다. 기본 클래스가 초기화 된 이후 파생 클래스가 초기화 됩니다.

open class Base(val name: String) {

    init { println("Initializing a base class") }

    open val size: Int = 
        name.length.also { println("Initializing size in the base class: $it") }
}

class Derived(
    name: String,
    val lastName: String,
) : Base(name.replaceFirstChar { it.uppercase() }.also { println("Argument for the base class: $it") }) {

    init { println("Initializing a derived class") }

    override val size: Int =
        (super.size + lastName.length).also { println("Initializing size in the derived class: $it") }
}

기반 클래스의 생성자가 실행될 때, 파생 클래스에서 선언된 프로퍼티나 override된 프로퍼티는 초기화 되어있지 않습니다. 기반 클래스의 초기화 로직에서 그러한 프로퍼티를 사용하는 것은 의도하지 않은 동작이나 런타임 에러를 유발할 수 있습니다. 따라서 기반 클래스를 설계할때, 초기화 로직(생성자, init블럭, 프로퍼티 초기화 구문)에서 open인 멤버를 사용하는 것을 피해야합니다.

Calling the superclass implementation

파생 클래스에서 super키워드를 사용하여 기반 클래스의 함수나 프로퍼티를 호출할 수 있습니다.

open class Rectangle {
    open fun draw() { println("Drawing a rectangle") }
    val borderColor: String get() = "black"
}

class FilledRectangle : Rectangle() {
    override fun draw() {
        super.draw()
        println("Filling the rectangle")
    }

    val fillColor: String get() = super.borderColor
}

내부 클래스에서 외부 클래스의 기반 클래스에 접근하려면 super 키워드에 외부 클래스의 이름을 한정하여 사용합니다.

class FilledRectangle: Rectangle() {
    override fun draw() {
        val filler = Filler()
        filler.drawAndFill()
    }

    inner class Filler {
        fun fill() { println("Filling") }
        fun drawAndFill() {
            super@FilledRectangle.draw() 
            // Calls Rectangle's implementation of draw()
            fill()
            println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // Uses Rectangle's implementation of borderColor's get()
        }
    }
}

Overriding rules

만약 어떤 한 클래스가 자신의 super class들로부터 같은 멤버의 여러 구현을 상속받는다면, 그 멤버는 반드시 오버라이딩 해야합니다.

super class로부터 어떤 상속된 구현을 가져오는지 표시하기 위해서는 꺽쇠 괄호와 클래스의 이름으로 super키워드를 한정해야합니다.

open class Rectangle {
    open fun draw() { /* ... */ }
}

interface Polygon {
    fun draw() { /* ... */ } // interface members are 'open' by default
}

class Square() : Rectangle(), Polygon {
    // The compiler requires draw() to be overridden:
    override fun draw() {
        super<Rectangle>.draw() // call to Rectangle.draw()
        super<Polygon>.draw() // call to Polygon.draw()
    }
}

Rectangle과 Polygon 모두에서 상속하는 것은 괜찮지만 둘 다 draw() 구현이 있으므로 Square에서 draw()를 오버라이딩하고 모호성을 제거하기 위해 별도의 구현을 제공해야 합니다.

출처

코틀린 공식 문서