Interface

Een interface is een blauwdruk voor abstracte eigenschappen en gedrag van objecten. Wij noemen objecten abstract als je ze niet kunt voorzien van implementatie.

Interfaces dragen bij aan de pijler abstraction bij het vertalen van een object uit de echte wereld naar code.

Let op: geen implementatie

Een interface bevat geen implementatie van de methoden die het definieert. Het bevat alleen de signatures van de methoden, de return types en de parameters.

Als een class een interface “implementeert” dan moet deze class de abstracte attributen voorzien van waarden en de abstracte methoden voorzien van een body.

Interface bieden onder andere een oplossing op plekken waar je van verschillende klassen zou willen overerven. Dit heet multiple inheritance en is in de meeste programmeertalen niet toegestaan.

In het onderstaande class diagram zien wij een voorbeeld van een class die Kat die subclass is van de klassen Dier, Spinner en Zwemmer. Nu heeft alleen de class Dier de methode maakGeluid() maar wat zou er gebeuren als de class Spinner dit ook had?

classDiagram
    class Dier {
        +maakGeluid(): void
    }
    class Spinner {
        +spin(): void
    }
    class Blaffer {
        +blaf(): void
    }
    class Zwemmer {
        +zwem(): void
    }
    class Kat {
        +maakGeluid(): void
        +spin(): void
        +zwem(): void
    }
    class Hond{
        +maakGeluid(): void
        +ren(): void
    }

    Dier <|-- Kat : erft van
    Dier <|-- Hond : erft van
    Spinner <|-- Kat : erft van
    Zwemmer <|-- Kat : erft van
    Blaffer <|-- Hond : erft van
    Zwemmer <|-- Hond : erft van

Let op: geen multiple inheritance

In de meeste programmeertalen is multiple inheritance niet toegestaan. Dit betekent dat een class niet van meerdere andere classes kan overerven.

In programmeertalen waar multiple inheritance wel is toegestaan kan het leiden tot problemen. Bijvoorbeeld als twee parent classes dezelfde methode hebben.

Over het algemeen is het beter om multiple inheritance te voorkomen en interfaces te gebruiken.

Om dit probleem te tackelen kun je naast overerving ook interfaces inzetten. In de onderstaande afbeelding zie je dat de klassen Hond en Kat beide child classes zijn van Huisdier. Een Kat is immers een Huisdier en een Hond ook. Aangezien niet elke Huisdier kan zwemmen is daar een aparte interface KanZwemmen met de abstracte methode zwemmen() voor aangemaakt. Zo kan elke Huisdier dat kan zwemmen deze interface implementeren en hier in zijn eigen class de methode voorzien van implementatie.

classDiagram 
    class KanZwemmen
        <<interface>> KanZwemmen 
        KanZwemmen: zwemmen()     

    class KanSpinnen
        <<interface>> KanSpinnen 
        KanSpinnen: spinnen()

    class KanBlaffen
        <<interface>> KanBlaffen 
        KanBlaffen: blaffen()

    class Huisdier{
        +String naam 
    }

    class Hond{
        +zwemmen() void 
        +blaffen() void
        +Boolean isGevaarlijk
    }

    class Kat{
        +zwemmen() void 
        +spinnen() void
    }

    Huisdier <|-- Kat : erft van
    Huisdier <|-- Hond: erft van

    Kat ..> KanSpinnen : implementeert
    Hond ..> KanBlaffen : implementeert
    Hond ..> KanZwemmen : implementeert
    Kat ..> KanZwemmen : implementeert

Bronnen

• “Geeks for Geeks” artikel over interfaces