코틀린 Interfaces

Interfaces

코틀린에서 인터페이스는 추상 메소드의 선언과 구현을 포함할 수 있습니다.
추상클래스와 인터페이스의 차이는 인터페이스는 프로퍼티의 상태를 저장할 수 없다는 것입니다. 즉, 인터페이스에서 프로퍼티를 초기화 할 수 없습니다.

인터페이스는 interface 키워드를 사용해서 정의할 수 있습니다.

interface MyInterface {
    fun bar() // this is abstract method
    fun foo() {
      // optional body
    } this is not abstract method
}

Implementing interfaces

class 또는 object는 한 개 이상의 인터페이스를 구현 할 수 있습니다.

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

Properties in interfaces

인터페이스에 프로퍼티를 선언할 수 있습니다.
인터페이스에서 선언된 프로퍼티는 abstract입니다. 또한 접근자에 대한 구현을 제공할 수 있습니다.
인터페이스에서 선언된 프로퍼티는 뒷받침 필드를 가질 수 없습니다. 그러므로 인터페이스에서 선언된 접근자는 뒷받침 필드를 참조할 수 없습니다.

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

인터페이스는 다른 인터페이스를 상속받을 수 있습니다. 인터페이스를 상속받은 인터페이스는 본래 인터페이스의 멤버와 상속된 인터페이스의 멤버 모두에 대해 구현할 수 있습니다.
자연스럽게도, 그러한 인터페이스를 구현하는 클래스는 오직 구현이 누락된 부분에 대해서만 구현하면 됩니다.

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

인터페이스를 사용하여 많은 종류의 무언가를 선언할 때, 이름이 똑같은 메소드의 구현이 하나 이상 존재할 수 있습니다.

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

인터페이스 A와 B는 둘 다 foo()와 bar() 함수를 선언합니다.
둘 다 foo에 대한 구현이 있지만, B만 bar를 구현하고 있습니다. (A에서 bar()는 인터페이스에서 body가 없는 함수는 기본적으로 abstract이기 때문에 abstract키워드가 없습니다.)
만약 당신이 C클래스에서 A를 상속받는다면, 당신은 반드시 bar를 오버라이딩하여 구현해야합니다.
하지만 만약 당신이 D에서 A와 B를 둘 다 상속받는다면, 당신은 다중 인터페이스로부터 상속받은 모든 메서드를 구현해야합니다. 그리고 당신은 D가 그것을 구현하는 방식을 명확하게 구체화시켜야합니다.
이 규칙은 단일 구현을 상속한 메서드(bar())와 여러 구현을 상속한 메서드(foo()) 모두에 적용됩니다.

출처

코틀린 공식문서