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

プロパティ

デフォルトの実装は、プロパティゲッタとセッタに対しても機能します。

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

インターフェイスアクセサ実装ではバッキングフィールドを使用できません

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

複数の実装

複数のインターフェイスが同じ関数を実装している場合、またはそれらのすべてが1つ以上の実装で定義されている場合、派生クラスは適切な呼び出しを手動で解決する必要があります

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
}

デフォルトの実装で複数のインタフェースを実装する場合の競合

デフォルトの実装を含む同じ名前のメソッドを持つ複数のインタフェースを実装する場合、どの実装を使用するべきかはコンパイラにとってあいまいです。競合が発生した場合、競合するメソッドをオーバーライドしてカスタム実装を提供する必要があります。この実装は、デフォルトの実装に委譲するかどうかを選択することができます。

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