Kotlin
인터페이스

비고

기본 인터페이스

Kotlin 인터페이스에는 추상 메소드의 선언과 기본 메소드 구현이 포함되어 있지만 상태를 저장할 수는 없습니다.

interface MyInterface {
    fun bar()
}

이 인터페이스는 이제 다음과 같이 클래스에 의해 구현 될 수 있습니다.

class Child : MyInterface {
   override fun bar() {
       print("bar() was called")
   }
}

기본 구현과의 인터페이스

Kotlin의 인터페이스는 함수에 대한 기본 구현을 가질 수 있습니다.

interface MyInterface {
    fun withImplementation() {
      print("withImplementation() was called")
    }
}

이러한 인터페이스를 구현하는 클래스는 함수를 다시 구현하지 않고도 해당 함수를 사용할 수 있습니다.

class MyClass: MyInterface {
    // No need to reimplement here
}
val instance = MyClass()
instance.withImplementation()

속성

기본 구현은 속성 getter 및 setter에도 적용됩니다.

interface MyInterface2 {
    val helloWorld
        get() = "Hello World!"
}

인터페이스 접근자는 구현 필드를 사용할 수 없다.

interface MyInterface3 {
    // this property won't compile!
    var helloWorld: Int
        get() = field
        set(value) { field = value }
}

여러 구현

여러 인터페이스가 동일한 함수를 구현하거나 모두가 하나 이상의 구현으로 정의되는 경우 파생 클래스는 적절한 호출을 수동으로 해결해야합니다.

interface A {
    fun notImplemented()
    fun implementedOnlyInA() { print("only A") }
    fun implementedInBoth() { print("both, A") }
    fun implementedInOne() { print("implemented in A") }
}

interface B {
    fun implementedInBoth() { print("both, B") }
    fun implementedInOne() // only defined
}

class MyClass: A, B {
    override fun notImplemented() { print("Normal implementation") }

    // implementedOnlyInA() can by normally used in instances

    // class needs to define how to use interface functions
    override fun implementedInBoth() {
        super<B>.implementedInBoth()
        super<A>.implementedInBoth()
    }

    // even if there's only one implementation, there multiple definitions
    override fun implementedInOne() {
        super<A>.implementedInOne()
        print("implementedInOne class implementation")
    }
}

인터페이스의 속성

인터페이스에서 속성을 선언 할 수 있습니다. 인터페이스는 상태를 가질 수 없기 때문에 속성을 추상적으로 선언하거나 접근 자의 기본 구현을 제공함으로써 선언 할 수 있습니다.

interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

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

기본 구현으로 여러 인터페이스를 구현할 때의 충돌

디폴트 구현을 포함한 같은 이름의 메소드를 가지는 2 개 이상의 인터페이스를 실장하는 경우, 어느 구현이 사용되어야하는지는 컴파일러에게 모호합니다. 충돌이있는 경우 개발자는 충돌하는 메서드를 재정의하고 사용자 지정 구현을 제공해야합니다. 이 구현은 기본 구현에 위임할지 여부를 결정할 수 있습니다.

interface FirstTrait {
    fun foo() { print("first") }
    fun bar()
}

interface SecondTrait {
    fun foo() { print("second") }
    fun bar() { print("bar") }
}

class ClassWithConflict : FirstTrait, SecondTrait {
    override fun foo() {
        super<FirstTrait>.foo()  // delegate to the default implementation of FirstTrait
        super<SecondTrait>.foo() // delegate to the default implementation of SecondTrait
    }

    // function bar() only has a default implementation in one interface and therefore is ok.
}

슈퍼 키워드

interface MyInterface {
    fun funcOne() {
        //optional body
        print("Function with default implementation")
    }
}

인터페이스의 메소드가 자체 기본 구현을 가지고 있다면 super 키워드를 사용하여 액세스 할 수 있습니다.

super.funcOne()