Kaip įgyvendinamos sąsajos Kotlin kalboje?

Sąsajos Kotlin įgyvendinamos naudojant raktinį žodį implements (neaišku Kotlin, tiesiog nurodoma per dvitaškį) arba by delegavimui.

Pagrindiniai įgyvendinimo būdai:

1. Tiesioginė įgyvendinimas: Objektas arba klasė tiesiogiai įgyvendina visas sąsajos narius.

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

   Paveldėjimas iš klasės ir sąsajų įgyvendinimas vienu metu, klasė nurodoma pirmiausia.

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

2. Įgyvendinimo delegavimas: Sąsajos įgyvendinimas deleguojamas kitam objektui. Naudojamas žodis by. Tai naudinga kompozicijai ir daugiavaikio paveldėjimo problemų išvengimui.

   interface DelegatedInterface {
       fun performAction()
   }
   
   class DelegatedObject : DelegatedInterface {
       override fun performAction() {
           println("Action performed by DelegatedObject")
       }
   }
   
   class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
       // ImplementingClass deleguoja performAction() metodo įgyvendinimą objektui di
   }
   

   Šiuo atveju ImplementingClass nesireiškia performAction savarankiškai, o iškvietimas performingClass.performAction() nukreipiamas į di.performAction().

Kai įgyvendinate kelis interfeisus su vienodais nariais, būtina išspręsti konfliktus, aiškiai perrašant narį ir nurodant, iš kurio interfeiso gaunama įgyvendinimas, naudojant <Interfeisas>.<narys> sintaksę.

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() // Iškviečiame `foo` įgyvendinimą iš InterfaceA
        super<InterfaceB>.foo() // Iškviečiame `foo` įgyvendinimą iš InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Naudojame `bar` įgyvendinimą iš InterfaceB
    }
}