공식 문서로 배우는 코틀린 - 16. Interfaces

열여섯 번째, 인터페이스입니다.

 

코틀린에서 인터페이스는 추상 메소드의 선언과 메소드의 구현을 모두 포함할 수 있습니다. 추상 클래스와 다른 점은 인터페이스는 상태(state)를 저장하지 못한다는 것입니다. 인터페이스는 프로퍼티를 가질 수는 있지만, 해당 프로퍼티는 추상적이거나 접근자 구현을 제공해야 합니다.

 

인터페이스는 interface라는 키워드를 가지고 정의합니다.

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

 

인터페이스 구현

클래스나 객체는 하나 이상의 인터페이스를 구현할 수 있습니다.

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

 

인터페이스의 프로퍼티

인터페이스에 프로퍼티를 선언할 수 있습니다. 인터페이스에 선언되는 프로퍼티는 추상적(abstract)이거나 또는 접근자 구현을 제공할 수 있습니다. 인터페이스에 선언된 프로퍼티는 뒷받침하는 필드를 가질 수 없고, 그에 따라 인터페이스에서 선언되는 접근다는 (당연히) 뒷받침하는 필드를 참조할 수 없습니다.

interface MyInterface {
    val prop: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(prop)
    }
}

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

 

인터페이스 상속

인터페이스는 다른 인터페이스에서 파생(derive)될 수 있습니다. 즉, 다른 인터페이스의 멤버들 구현을 제공하고, 새로운 함수와 프로퍼티를 선언할 수 있습니다. 아주 당연하게도, 그런 인터페이스를 구현하는 클래스는 단지 구현되지 않은 것들만 필수로 정의하면 됩니다.

interface Named {
    val name: String
}

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

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

data class Employee(
    // 'name'은 구현이 요구되지 않습니다.
    override val firstName: String,
    override val lastName: String,
    val position: Position
) : Person

 

오버라이딩 충돌 해결

둘 이상의 수퍼 타입을 상속 받을 때, 어떤 경우에는 같은 이름으로 구현된 메소드가 하나 이상일 수 있습니다.

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() // <B>는 생갹 가능합니다.
    }
}

 

인터페이스 A와 B는 둘 다 함수 foo()와 bar()를 선언하고 있습니다. 둘 다 foo()를 구현하고 있지만, bar()는 B만 구현합니다(A에서 bar()는 abstract로 지정되지 않았는데, 인터페이스에서 몸체가 없는 함수는 기본이 추상적이기 때문에 abstract를 지정하지 않습니다). 이제 A를 상속하는 구체 클래스 C를 선언하고, bar()를 오버라이딩 한 후 구현을 제공합니다.

 

하지만, A, B를 상속하는 D를 선언하는 경우 다중 인터페이스로부터 상속 받는 모든 메소드를 구현해야 합니다. 그리고, D가 그것들을 정확히 어떻게 구현해야 하는지 명시해야 합니다(즉, 상속 받은 구현들을 재사용하는 경우 어느 타입의 것인지 명시해야 합니다). 이 규칙은 하나의 구현만 상속 받은 bar()와 두 개의 구현을 상속 받은 foo() 모두에 해당 됩니다.