[내보내번] Inheritance | Kotlin

Kotlin을 공부하면서 상속에 대한 부분을 공부하고자 공식 문서를 직접 번역했다.
해당 문서는 2022년 3월 2일자 공식 문서이다. 

Kotlin 공식문서 확인하기 ➡️

Inheritance | Kotlin

 

※ 영어 전공자도 해외 유학파도 아니기에 번역에는 의역, 오역, 구글 번역이 무수히 많을 수 있으며, 혼자 공식문서를 참조해가며 번역하다 보니 오타도 많을 수 있다. 정확한 내용은 공식문서를 직접 살펴보거나 다른 정보들을 더 찾아보는 것을 추천한다.

(하지만 댓글 피드백도 환영합니다😃 )

 

All classes in Kotlin have a common superclass, Any, which is the default superclass for a class with no supertypes declared:

코틀린에 있는 모든 클래스에는 공통 슈퍼클래스 Any가 있는데, 이것은 선언된 슈퍼타입이 없는 클래스의 기본 슈퍼클래스이다.

class Example // Implicitly inherits from Any

 

Any has three methods: equals(), hashCode(), and toString(). Thus, these methods are defined for all Kotlin classes.

Any는 3가지 메서드를 갖고 있다: equals(), hashCode(), toString(). 그러므로 이 메서드들은 모든 코틀린 클래스들에도 정의되어 있다.

By default, Kotlin classes are final – they can’t be inherited. To make a class inheritable, mark it with the open keyword:

기본값으로 코틀린 클래스들은 final이다 즉 상속될 수 없다. 클래스를 상속 가능하게 만들려면 open 키워드로 표시를 해주어야한다: 

open class Base // Class is open for inheritance

 

To declare an explicit supertype, place the type after a colon in the class header:

명시적인 슈퍼타입을 선언하려면 명시하려는 그 타입을 class 헤더에 콜론(:) 뒤에 두어라: 

open class Base(p: Int)

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

If the derived class has a primary constructor, the base class can (and must) be initialized in that primary constructor according to its parameters.

만약 파생된 클래스가 기본(primary) 생성자를 가지고 있다면 기본(base) 클래스는 기본 생성자에서 파라미터에 따라 초기화 될 수 (초기화 되어야 한다)있다.

If the derived class has no primary constructor, then each secondary constructor has to initialize the base type using the super keyword or it has to delegate to another constructor which does. Note that in this case different secondary constructors can call different constructors of the base type:

만약 파생 클래스에 기본(primary) 생성자가 없다면, 각 보조(secondary) 생성자는 기본 타입을 super 키워드를 사용하여 초기화 하거나 그렇게 하는 다른 생성자에 위임해야한다. 이 경우 다른 보조 생성자가 기본 타입의 다른 생성자를 호출할 수 있다: 

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

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

 

Overriding methods

Kotlin requires explicit modifiers for overridable members and overrides:

코틀린은 오버라이딩 가능한 멤버와 오버라이드 함수에 대해 명시적인 수식어가 요구 된다: 

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

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

 

The override modifier is required for Circle.draw(). If it were missing, the compiler would complain. If there is no open modifier on a function, like Shape.fill(), declaring a method with the same signature in a subclass is not allowed, either with override or without it. The open modifier has no effect when added to members of a final class – a class without an open modifier.

오버라이드 수식어는 Circle.draw()에 요구 된다. 만약 이 수식어가 없으면, 컴파일러가 이것에 대해 불평할 것이다. (한국어로는 어색한 표현이지만;;) Shape.fill()과 같이 open 수식어가 함수 앞에 없으면 override 수식어가 있든 없든 서브클래스에서 동일한 signature를 갖고 있는 메서드를 정의하는 것은 허용되지 않는다. open 수식어는 final 클래스 - open 수식어가 없는 클래스의 멤버에게 붙여져도 아무 효력이 없다. 

A member marked override is itself open, so it may be overridden in subclasses. If you want to prohibit re-overriding, use final:

override로 표시된 멤버 자체가 열려(open)있기 때문에 서브클래스에서 오버라이드 될 수 있다. 재-오버라이딩을 금지하고 싶다면 final을 사용하라:

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

 

 

Overriding properties

The overriding mechanism works on properties in the same way that it does on methods. Properties declared on a superclass that are then redeclared on a derived class must be prefaced with override, and they must have a compatible type. Each declared property can be overridden by a property with an initializer or by a property with a get method:

오버라이딩 메커니즘은 메서드에 적용된 것과 같은 방식으로 속성들에도 적용된다. 슈퍼클래스에서 선언된 후 파생클래스에서 재선언된 속성은 override로 시작해야하고 호환 가능한 타입이 있어야한다. 각 선언된 속성은 initializer가 있는 속성이나 get 메서드가 있는 속성에 의해 오버라이드 될 수 있다:

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

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

 

You can also override a val property with a var property, but not vice versa. This is allowed because a val property essentially declares a get method, and overriding it as a var additionally declares a set method in the derived class.

val 속성을 var 속성으로 오버라이드할 수 있지만 반대의 경우는 불가능하다. 👀 이것이 허용되는 이유는 val 속성이 본질적으로 get 메서드를 선언하고 이것을 var로 오버라이드하면 파생클래스에서 set 메서드를 추가 선언하기 때문이다. 

Note that you can use the override keyword as part of the property declaration in a primary constructor:

기본 생성자에서 속성 선언의 일부분으로 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

During the construction of a new instance of a derived class, the base class initialization is done as the first step (preceded only by evaluation of the arguments for the base class constructor), which means that it happens before the initialization logic of the derived class is run.

파생클래스의 새로운 인스턴스를 생성하는 동안, 기본클래스의 초기화는 첫 번째로(기본클래스 생성자에 대한 인자 평가에 의해서만 선행됨) 이루어지는데, 이것의 의미는 파생클래스의 초기화 로직이 실행되기 전에 해당 동작이 이루어진다는 것이다.

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") }
}

fun main() {
    println("Constructing the derived class(\"hello\", \"world\")")
    Derived("hello", "world")
}

 

아래는 위의 코드에 대한 출력이다.

 

Constructing the derived class("hello", "world")
Argument for the base class: Hello
Initializing a base class
Initializing size in the base class: 5
Initializing a derived class
Initializing size in the derived class: 10​

This means that when the base class constructor is executed, the properties declared or overridden in the derived class have not yet been initialized. Using any of those properties in the base class initialization logic (either directly or indirectly through another overridden open member implementation) may lead to incorrect behavior or a runtime failure. When designing a base class, you should therefore avoid using open members in the constructors, property initializers, or init blocks.

이 의미는 기본 클래스 생성자가 실행되었을 때 파생클래스에 있는 선언된 속성들이나 오버라이드 된 것들이 아직 초기화 되지 않았다는 것이다. 기본클래스 초기화 로직에서 (직접적으로든 오버라이드된 다른 open 멤버 구현을 통해 간접적으로든) 이러한 속성들 중 어느 것이든 사용하는 것은 잘못된 동작이나 런타임 오류를 초래할 수 있다. 그러므로 기본클래스를 설계할 때 생성자, 속성, initializer 혹은 초기화 블럭에서 open 멤버를 사용하는 것은 피해야한다. 

 

Calling the superclass implementation

Code in a derived class can call its superclass functions and property accessor implementations using the super keyword:

파생클래스의 코드는 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
}

 

Inside an inner class, accessing the superclass of the outer class is done using the super keyword qualified with the outer class name: super@Outer:

내부 클래스 안에서 외부 클래스의 슈퍼클래스에 접근하는 것은 super 키워드와 외부 클래스 이름을 사용하면 가능하다: super@Outer:

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

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()
        }
    }
}

fun main() {
    val fr = FilledRectangle()
        fr.draw()
}

아래는 위의 코드에 대한 출력이다.

Drawing a rectangle
Filling
Drawn a filled rectangle with color black

 

Overriding rules

In Kotlin, implementation inheritance is regulated by the following rule: if a class inherits multiple implementations of the same member from its immediate superclasses, it must override this member and provide its own implementation (perhaps, using one of the inherited ones).

코틀린에서 상속 구현은 다음의 규칙들로 규정된다: 클래스가 직계 슈퍼클래스로부터 동일한 멤버의 여러 구현을 상속하는 경우, 클래스는 반드시 이 멤버를 오버라이드하고 고유한 구현을 제공해야한다(아마도 상속된 것 중 하나를 사용하여서).

To denote the supertype from which the inherited implementation is taken, use super qualified by the supertype name in angle brackets, such as super<Base>:

상속된 구현이 어디서부터 온 것인지 슈퍼타입을 표시하기 위해서는 super<Base>와 같이 꺾쇠 괄호 안에 슈퍼타입 이름으로 한정되는 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()
    }
}

 

It's fine to inherit from both Rectangle and Polygon, but both of them have their implementations of draw(), so you need to override draw() in Square and provide a separate implementation for it to eliminate the ambiguity.

Rectangle과 Polygon 모두로부터 상속받는 것은 문제 없지만 둘다 draw()이 구현되어 있기 때문에 Square에서 draw()를 오버라이드해야하고 모호성을 없애기 위해 별도의 구현을 제공해야한다.