[내보내번] Interfaces | Kotlin

Kotlin을 공부하면서 상속에 대한 부분을 공부하고자 공식 문서를 직접 번역했다.
해당 문서는 2022년 3월 3일자 공식 문서이다.
중간중간 👀 표시가 있는 문장이나 소제목은 번역이 부정확할 수 있으며 구글이나 파파고 번역기의 도움을 받았다. 

Kotlin 공식문서 확인하기 ➡️

Interfaces | Kotlin

 

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

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

 

Interfaces in Kotlin can contain declarations of abstract methods, as well as method implementations. What makes them different from abstract classes is that interfaces cannot store a state. They can have properties, but these need to be abstract or provide accessor implementations.

코틀린의 인터페이스는 추상 메서드 선언과와 메서드 구현 모두 포함할 수 있다. 추상 클래스와의 차이점은 인터페이스는 상태를 저장할 수 없다는 것이다. 인터페이스는 속성을 가질 수 있지만 추상이거나 접근자 구현이 제공되어야한다. 

An interface is defined using the keyword interface:

인터페이스는 interface 키워드로 정의된다: 

interface MyInterface {
    fun bar()
    fun foo() {
      // optional body
    }
}

 

Implementing interfaces

A class or object can implement one or more interfaces:

클래스나 객체는 하나 혹은 그 이상의 인터페이스를 구현할 수 있다:

class Child : MyInterface {
    override fun bar() {
        // body
    }
}

 

Properties in interfaces

You can declare properties in interfaces. A property declared in an interface can either be abstract or provide implementations for accessors. Properties declared in interfaces can't have backing fields, and therefore accessors declared in interfaces can't reference them:

인터페이스에 속성을 선언할 수 있다. 인터페이스에 선언된 속성은 추상이거나 접근자를 위한 구현이 제공되어야한다. 인터페이스에 선언된 속성들은 backing 필드를 가질 수 없고 그렇기 때문에 인터페이스에 선언된 접근자는 접근할 수 없다. 

interface MyInterface {
    val prop: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(prop)
    }
}

class Child : MyInterface {
    override val prop: Int = 29
}

 

Interfaces Inheritance

An interface can derive from other interfaces, meaning it can both provide implementations for their members and declare new functions and properties. Quite naturally, classes implementing such an interface are only required to define the missing implementations:

인터페이스는 다른 인터페이스로부터 파생될 수 있다. 즉, 멤버를 위한 구현을 제공하는 것과 새로운 함수와 속성을 선언하는 것 둘 다 가능한 것을 의미한다. 당연히 그러한 인터페이스를 구현한 클래스는 구현되지 않은 부분만 정의하는 것만 요구된다.  

interface Named {
    val name: String
}

interface Person : Named {
    val firstName: String
    val lastName: String

    override val name: String get() = "$firstName $lastName"
}

data class Employee(
    // implementing 'name' is not required
    override val firstName: String,
    override val lastName: String,
    val position: Position
) : Person

 

Resolving overriding conflicts

When you declare many types in your supertype list, you may inherit more than one implementation of the same method:

슈퍼타입 목록에서 많은 타입들을 선언할 때 동일 메소드에 대해 하나 이상의 구현을 상속할지 모른다: 

interface A {
    fun foo() { print("A") }
    fun bar()
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }

    override fun bar() {
        super<B>.bar()
    }
}

 

Interfaces A and B both declare functions foo() and bar(). Both of them implement foo(), but only B implements bar() (bar() is not marked as abstract in A, because this is the default for interfaces if the function has no body). Now, if you derive a concrete class C from A, you have to override bar() and provide an implementation.

인터페이스 A와 B 모두 함수 foo()와 bar()를 선언했다. 모두 foo()는 구현했지만 B만 bar()를 구현했다(bar()는 A에서 abstract으로 표시되지 않았는데 이것이 인터페이스에서 함수에 바디가 없을 때의 기본값이기 때문이다). 이제 A로부터 클래스 C를 파생하려면 bar()를 오버라이드하고 구현을 제공해야한다. 

However, if you derive D from A and B, you need to implement all the methods that you have inherited from multiple interfaces, and you need to specify how exactly D should implement them. This rule applies both to methods for which you've inherited a single implementation (bar()) and to those for which you've inherited multiple implementations (foo()).

그런데 D를 A와 B로부터 파생하려면 다수의 인터페이스에서 상속받은 모든 메서드들을 구현해야하고 D가 어떻게 구체적으로 그들을 구현했는지 명시해야한다. 이 규칙은 bar()과 같이 단일 구현을 상속한 메서드와 foo()같이 여러 구현을 상속한 메서드 모두에 적용된다.