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

Несколько реализаций

Когда несколько интерфейсов реализуют одну и ту же функцию или все из них определяют с одним или несколькими реализациями, производный класс должен вручную разрешить правильный вызов

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