Как се реализират интерфейсите в Kotlin?

Интерфейсите в Kotlin се реализират с използване на ключовата дума implements (неявно в Kotlin, просто се посочва чрез двоеточие) или by за делегиране.

Основните начини за реализация:

1. Пряка реализация: Обект или клас реализира всички членове на интерфейса директно.

   interface MyInterface {
       fun doSomething()
       val myProperty: String
   }
   
   class MyClass : MyInterface {
       override fun doSomething() {
           println("Doing something in MyClass")
       }
   
       override val myProperty: String = "Hello"
   }
   

   При наследяване от клас и реализиране на интерфейси едновременно, класът се посочва първи.

   open class BaseClass
   
   class AnotherClass : BaseClass(), MyInterface {
       override fun doSomething() {
           println("Doing something in AnotherClass")
       }
   
       override val myProperty: String = "World"
   }
   

2. Делегиране на реализация: Реализацията на интерфейса се делегира на друг обект. Използва се ключовата дума by. Това е полезно за композиция и избягване на проблеми с множествено наследяване на реализация.

   interface DelegatedInterface {
       fun performAction()
   }
   
   class DelegatedObject : DelegatedInterface {
       override fun performAction() {
           println("Action performed by DelegatedObject")
       }
   }
   
   class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
       // ImplementingClass делегира реализацията на метода performAction() на обекта di
   }
   

   В този случай ImplementingClass не реализира performAction самостоятелно, а извикването performingClass.performAction() се пренасочва към di.performAction().

При реализиране на няколко интерфейса с едноименни членове, е необходимо да се разрешат конфликтите, явно пренаписвайки члена и посочвайки от кой интерфейс се взема реализацията, използвайки синтаксис <Интерфейс>.<член>.

interface InterfaceA {
    fun foo() { println("InterfaceA") }
    fun bar()
}

interface InterfaceB {
    fun foo() { println("InterfaceB") }
    fun bar() { println("InterfaceB bar") }
}

class ResolvingConflict : InterfaceA, InterfaceB {
    override fun foo() {
        super<InterfaceA>.foo() // Извикваме реализацията на foo от InterfaceA
        super<InterfaceB>.foo() // Извикваме реализацията на foo от InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Използваме реализацията на bar от InterfaceB
    }
}