Jak se v Kotlinu realizují rozhraní?

Rozhraní v Kotlinu jsou implementována pomocí klíčového slova implements (implicitně v Kotlinu, jednoduše označeno dvojtečkou) nebo by pro delegaci.

Hlavní způsoby implementace:

1. Přímá implementace: Objekt nebo třída přímo implementuje všechny členy rozhraní.

   interface MyInterface {
       fun doSomething()
       val myProperty: String
   }
   
   class MyClass : MyInterface {
       override fun doSomething() {
           println("Dělám něco v MyClass")
       }
   
       override val myProperty: String = "Ahoj"
   }
   

   Při dědění z třídy a současném implementování rozhraní je třída uvedena jako první.

   open class BaseClass
   
   class AnotherClass : BaseClass(), MyInterface {
       override fun doSomething() {
           println("Dělám něco v AnotherClass")
       }
   
       override val myProperty: String = "Svět"
   }
   

2. Delegace implementace: Implementace rozhraní je delegována na jiný objekt. Používá se klíčové slovo by. To je užitečné pro kompozici a pro vyhýbání se problémům s vícenásobnou dědičností implementace.

   interface DelegatedInterface {
       fun performAction()
   }
   
   class DelegatedObject : DelegatedInterface {
       override fun performAction() {
           println("Akce prováděna DelegatedObject")
       }
   }
   
   class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
       // ImplementingClass deleguje implementaci metody performAction() na objekt di
   }
   

   V tomto případě ImplementingClass neimplementuje performAction sám, místo toho volání performingClass.performAction() je přesměrováno na di.performAction().

Při implementaci více rozhraní s členy se stejným názvem je nutné konflikty řešit, výslovným přepsáním člena a určením, z jakého rozhraní se bere implementace, pomocí syntaxe <Rozhraní>.<člen>.

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() // Volání implementace foo z InterfaceA
        super<InterfaceB>.foo() // Volání implementace foo z InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Použití implementace bar z InterfaceB
    }
}