인터페이스

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

인터페이스는 interface 키워드를 사용하여 정의됩니다:

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

인터페이스 구현하기

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

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

인터페이스의 프로퍼티

인터페이스에 프로퍼티를 선언할 수 있습니다. 인터페이스에 선언된 프로퍼티는 추상적이거나 접근자에 대한 구현을 제공할 수 있습니다. 인터페이스에 선언된 프로퍼티는 백킹 필드를 가질 수 없으므로, 인터페이스에 선언된 접근자는 이를 참조할 수 없습니다:

interface MyInterface {
    val prop: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(prop)
    }
}

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

인터페이스 상속

인터페이스는 다른 인터페이스에서 파생될 수 있으며, 이는 해당 인터페이스의 멤버에 대한 구현을 제공하고 새로운 함수와 프로퍼티를 선언할 수 있음을 의미합니다. 당연하게도, 이러한 인터페이스를 구현하는 클래스는 누락된 구현만 정의하면 됩니다:

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

오버라이딩 충돌 해결

상위 타입 목록에 여러 타입을 선언하면, 동일한 메서드의 구현을 두 개 이상 상속받을 수 있습니다:

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()*를 구현하지만, *bar()*는 B만 구현합니다 (A에서 *bar()*가 추상으로 표시되지 않은 것은, 함수에 본문이 없는 경우 인터페이스의 기본값이기 때문입니다). 이제, A에서 구체 클래스 C를 파생하면, *bar()*를 오버라이드하고 구현을 제공해야 합니다.

하지만 A와 B에서 D를 파생하는 경우, 여러 인터페이스로부터 상속받은 모든 메서드를 구현해야 하며, D가 이들을 어떻게 정확히 구현해야 하는지 명시해야 합니다. 이 규칙은 단일 구현을 상속받은 메서드(bar())와 여러 구현을 상속받은 메서드(foo()) 모두에 적용됩니다.

인터페이스 함수의 JVM 기본 메서드 생성

JVM에서 인터페이스에 선언된 함수는 기본 메서드로 컴파일됩니다. 다음 값을 사용하여 -jvm-default 컴파일러 옵션으로 이 동작을 제어할 수 있습니다:

• enable (기본값): 인터페이스에 기본 구현을 생성하고 서브클래스 및 DefaultImpls 클래스에 브릿지 함수를 포함합니다. 이 모드를 사용하여 이전 Kotlin 버전과의 바이너리 호환성을 유지합니다.
• no-compatibility: 인터페이스에만 기본 구현을 생성합니다. 이 모드는 호환성 브릿지 및 DefaultImpls 클래스를 건너뛰므로, 새로운 Kotlin 코드에 적합합니다.
• disable: 기본 메서드를 건너뛰고 호환성 브릿지 및 DefaultImpls 클래스만 생성합니다.

-jvm-default 컴파일러 옵션을 구성하려면, Gradle Kotlin DSL에서 jvmDefault 프로퍼티를 설정하세요:

kotlin {
    compilerOptions {
        jvmDefault = JvmDefaultMode.NO_COMPATIBILITY
    }
}