Antwoord.

In Kotlin is gedragdelegatie geïmplementeerd met behulp van het taalmechanisme van het sleutelwoord by, direct in de handtekening van de klasse. Dit stelt je in staat om automatisch methoden van een interface (of meerdere interfaces) naar een andere objectimplementatie door te geven, waardoor boilerplate-code vermindert en compositie wordt vergemakkelijkt.

Achtergrond

De opkomst van interfacedelegatie is een poging om de beperkingen en tekortkomingen van meervoudige overerving te verhelpen. Dit is het idee van "compositie boven overerving" — je delegeert gedrag zonder een klassenhiërarchie te creëren. Geleend uit talen waar compositie populairder is (bijvoorbeeld Go, Scala).

Probleem

In Java en andere talen moet je vaak een interface maken en handmatig elke methode implementeren, waarbij je de logica naar een ander veld doorgeeft (Object Adapter-patroon), wat snel verouderd raakt naarmate het aantal methoden toeneemt.

Oplossing

Kotlin maakt het mogelijk om declaratief een interface te delegeren met behulp van by:

interface Logger {
    fun log(msg: String)
}
class ConsoleLogger: Logger {
    override fun log(msg: String) = println(msg)
}
class Service(logger: Logger): Logger by logger {
    fun doWork() {
        log("Werk gestart")
        // ...
    }
}
val service = Service(ConsoleLogger())
service.doWork()

Alle methoden van Logger worden geïmplementeerd via het meegeleverde object logger, zonder dat in de klasse Service expliciet methoden hoeven te worden overschreven of geproxieerd.

Belangrijke eigenschappen:

Maakt het mogelijk om de implementatie van de interface van het gebruik te scheiden, waardoor code duplicatie vermindert
Delegatie is flexibeler dan overerving en werkt met meerdere gedragingen
Ondersteunt de beste SOLID-praktijken

Vragen met een twist.

Wat gebeurt er als je in de klasse Service je eigen methode van de interface met dezelfde handtekening toevoegt?

De eigen implementatie "overschrijft" de gedelegeerde — dat wil zeggen, de methode die expliciet in de klasse is gedefinieerd, heeft voorrang:

class Service(logger: Logger): Logger by logger {
    override fun log(msg: String) = println("PREFIX: $msg")
}

Kan één klasse meerdere interfaces aan verschillende objecten delegeren?

Ja, een klasse kan meerdere interfaces implementeren en deze aan verschillende objecten delegeren, maar elke interface wordt aan één object gedelegeerd:

class Service(
    logger: Logger,
    tracker: Tracker
): Logger by logger, Tracker by tracker

Wat is het verschil tussen interfacedelegatie en eigenschapdelegatie via by?

Interfacedelegatie geeft de volledige implementatie van de interfacefuncties door aan een ander object.
Eigenschapdelegatie (property delegation) delegeert de verwerking van get/set naar een specifieke type delegated-object (ReadOnlyProperty, ReadWriteProperty).

Typische fouten en anti-patronen

Delegatie van te grote interfaces (schending van ISP)
Gelijktijdig gebruik van expliciete implementatie en delegatie (onverwacht gedrag)
Poging om interfacedelegatie en overerving van de bovenliggende klasse te combineren, met inachtneming van de volgorde van methodeoplossing

Voorbeeld uit het leven

Negatieve case

De klasse implementeert handmatig de interface, elk method aanroept het delegaat, en bij het toevoegen van nieuwe methoden vergeten ze de proxering bij te werken, wat tot fouten leidt.

Voordelen:

De logica wordt expliciet gecontroleerd

Nadelen:

Hoog risico op fouten, boilerplate
Slecht schaalbaar bij groei van de interface

Positieve case

Taaldelegatie wordt gebruikt, alleen niet-standaard methoden worden binnen de klasse geïmplementeerd, nieuwe functionaliteit wordt toegevoegd zonder grote wijzigingen.