Wat leer je in dit hoofdstuk?

Na dit hoofdstuk kan je:

uitleggen wat een interface is en hoe ze verschilt van een klasse

een interface definiëren en in een klasse implementeren

kiezen tussen een interface en een abstracte klasse

meerdere interfaces combineren (waar overerving tekortschiet)

eigen objecten sorteerbaar maken met IComparable

met is en as objecten op een interface bevragen

Interfaces in de echte wereld

“Interface” = tussen vlakken: de afgesproken verbinding tussen twee systemen.

Een auto

stuur en pedalen, ongeacht benzine of elektrisch

Een pc

USB, HDMI, audio, … wereldwijd afgesproken aansluitingen

Ken je de interface, dan kan je ze gebruiken zonder de interne werking te kennen.

Belangrijk

Dit gaat niet over grafische User Interfaces. U weze gewaarschuwd.

Interfaces in OOP

Een interface is een belofte: een beschrijving van publieke methoden en properties die een klasse belooft te hebben, zonder de implementatie.

Zoals een fotocamera met een HDMI- en een USB-aansluiting, zo maak je een klasse met de interfaces ISecure en IStreamable. Het is als een sticker USB 3.0 compatibel:

je weet wat het apparaat kan

niet hoe het binnenin werkt

Een interface in C#

interface ISuperHeld
{
    void SchietLasers();
    int VerlaagKracht(bool isZwak);
    int Power { get; set; }
}

I interface in plaats van class, naam start met een I

public Geen public (alles is publiek)

; Geen code: elke signatuur eindigt op ;

De regels

Geen instantievariabelen en geen constructors

Geen access modifier nodig: alles is public

Je mag wel nieuwe types (bv. een enum) declareren

Een interface erft niet van een klasse, wel van andere interfaces

In de regel geen code, enkel signaturen

Tip

Sinds C# 8 bestaan default interface methods (met code), maar we houden het bewust bij zuivere signaturen.

Interface of abstracte klasse?

Abstracte klasse Interface
Gedeelde code ja nee
Instantievariabelen ja nee
Constructors ja nee
Hoeveel combineren? 1 meerdere
Relatie “is een” “kan iets”

Tip

Een Vogel en een Vliegtuig kunnen allebei vliegen, maar delen geen parent-klasse. Een gedeelde IVliegt kan dus enkel via een interface.

Stagiair Steven

Steven laat een Fiets de interface IVoertuig implementeren:

interface IVoertuig
{
    int AantalWielen { get; set; }
    void Rijd();
}

internal class Fiets : IVoertuig
{
    public int AantalWielen { get; set; } = 2;
}

“Een abstracte klasse liet me toch ook methoden ongemoeid?” Waarom weigert de compiler hier?

Stagiair Steven: wat liep er mis?

De compiler klaagt: 'Fiets' does not implement interface member 'IVoertuig.Rijd()'

Opmerking

Een interface is altijd een volledige belofte: alle methoden en properties moet je zelf voorzien, anders compileert je klasse niet. Een abstracte klasse kan gedeelde code meegeven, een interface heeft geen eigen code om op terug te vallen. Steven moest Rijd() zelf schrijven.

Interfaces en klassen

Een klasse implementeert een interface

internal class Zorro : ISuperHeld
{
    public void RoepPaard() { ... }
    public bool HeeftSnor { get; set; }

    public void SchietLasers() { Console.WriteLine("pewpew"); }
    public int VerlaagKracht(bool isZwak)
    {
        if (isZwak) return 5;
        return 10;
    }
    public int Power { get; set; }
}

Zolang Zorro niet alles uit ISuperHeld implementeert, compileert de klasse niet.

Overerven én meerdere interfaces mag ook: internal class DarthVader : StarWarsCharacter, IForceUser, IPilot

Interfaces in UML

Een “lolly” op een klasse geeft aan dat ze een interface heeft. Hier heeft WerkStudent de interface IVerkortTraject:

Interface UML notatie.

Een interface visualiseren

Een interface is als een blad met gaten: leg je het op een klasse die de belofte nakomt, dan vallen de gaten precies over de juiste methoden en properties.

Het lolly’tje is een haakje.

Daar hangt de interface aan.

Sommige klassen “zijn” superhelden?

Een spel met monsters, mensen, huizen en voertuigen: vier groepen zonder gemeenschappelijke parent.

Sommige monsters worden superheld

Sommige mensen ook

En zelfs enkele voertuigen (Transformers!)

Waarschuwing

Je kan maar van één klasse overerven. Een klasse kan wel meerdere interfaces hebben: ze is een voertuig, en heeft daarnaast de interface ISuperHeld. De interface bevat niet de code van wat een superheld doet, enkel de belofte.

Lampje wederom to the rescue

Schrijf de klasse-signatuur, klik op het lampje en kies “Implement interface”. En presto!

Verschijnt het lampje niet? Rechterklik op het rood onderstreepte woord en kies “Quick Actions and Refactorings…”.

Het is-keyword met interfaces

Boek implementeert IVerwijderbaar, Persoon niet:

Persoon tim = new Persoon();
Boek gameOfThrones = new Boek();

if (gameOfThrones is IVerwijderbaar)
{
    Console.WriteLine("Ik kan Game of Thrones verwijderen");
}
if (tim is IVerwijderbaar)
{
    Console.WriteLine("Ik kan Tim verwijderen");
}
Ik kan Game of Thrones verwijderen

De kracht zie je pas in een lijst met een allegaartje aan objecten:

foreach (var persoon in werkNemers)
{
    if (persoon is IManager)
    {
        //...
    }
}

Meerdere interfaces

Een klasse erft van maar één parent, maar mag meerdere interfaces dragen:

interface ISuperHeld {...}
interface ICoureur {...}
internal class Man {...}

internal class Zorro : Man, ISuperHeld {...}
internal class Batman : Man, ISuperHeld, ICoureur {...}

Tip

De volgorde is belangrijk: eerst de klasse waarvan je overerft, dan pas de interface(s).

Interfaces die van elkaar erven

Een nieuwe interface die álles van een bestaande moet kunnen, plus wat extra:

interface IGod : ISuperHeld
{
    void MaakRegen(); //extra bovenop ISuperHeld
}

Wie IGod implementeert, moet dus ook alle methoden van ISuperHeld voorzien.

Is dat geen overkill?

In kleine projecten lijken interfaces overkill, en dat zijn ze vaak ook

Werken veel klassen met elkaar samen, dan worden interfaces je dikke vrienden

De SOLID-principes vragen enerzijds abstractie (je hoeft de gore details van een klasse niet te kennen) en anderzijds separation of concerns (elk deel van je code heeft één opdracht).

Met interfaces boeit het je niet meer wat er in een klasse zit: aan haar interfaces zie je wat ze kan.

Interfaces in de praktijk

Minister als bij-job

Met de abstracte klasse Minister uit H16 kan een minister enkel minister zijn: C# kent geen multiple inheritance. Maar je wordt niet geboren als minister.

interface IMinister
{
    void Adviseer();
}
internal class Ceo : IMinister
{
    public void Adviseer()
    {
        Console.WriteLine("Vrijhandel is essentieel!");
    }
    public void MaakJaarlijkseOmzet()
    {
        Console.WriteLine("Geld!!!");
    }
    public void OntslaDepartement()
    {
        Console.WriteLine("You're all fired!");
    }
}

De CEO blijft zijn bestaande job doen, maar kan nu ook minister zijn.

De premier werkt met IMinister

internal class EersteMinister
{
    public void Regeer()
    {
        List<IMinister> AlleMinisters
            = new List<IMinister>();
        AlleMinisters.Add(new Ceo());
        foreach (IMinister minister in AlleMinisters)
        {
            minister.Adviseer();
        }
    }
}
internal class MinisterVanMilieu : IMinister
{
    public void Adviseer()
    {
        VerhoogBosSubsidies();
        OpenOnderzoek();
        ContacteerGreenpeace();
    }
    //...
}

Bij de bestaande ministers verandert enkel lijn 1.

Interfaces, compositie en polymorfisme samen: eender wie kan minister worden zonder zijn job op te zeggen.

Bestaande interfaces in .NET

.NET zit vol interfaces

IEnumerable

IDisposable

IList

IQueryable

Wil je eigen klasse bepaalde bestaande methoden gebruiken, dan moet ze aan zo’n interface voldoen.

De makers van .NET kunnen niet voorspellen hoe jij hun bibliotheken gaat gebruiken. Via interfaces geven ze de krijtlijnen.

IComparable, stap 1: het probleem

We willen landen sorteren op oppervlakte:

internal class Land
{
    public string Naam {get;set;}
    public int Oppervlakte {get;set;}
    public int Inwoners {get;set;}
}
Land[] eurolanden = new Land[3];
eurolanden[0] = new Land() {Naam = "België",
    Oppervlakte = 5, Inwoners = 2000};
// ... Frankrijk en Nederland
Array.Sort(eurolanden);
InvalidOperationException: Failed to compare two elements in the array

Opmerking

Logisch: .NET weet niet hoe het een Land moet sorteren. Alfabetisch op Naam? Op Inwoners? Enkel jij weet het.

Stap 2: IComparable onderzoeken

De interface uit de documentatie:

interface IComparable
{
    int CompareTo(Object obj);
}

Belangrijk

Deze interface bestaat al in .NET: schrijf ze niet opnieuw.

CompareTo geeft Betekenis
kleiner dan 0 huidig object komt voor obj
0 zelfde positie als obj
groter dan 0 huidig object komt na obj

Array.Sort werkt tegen deze interface en verwacht een int volgens die afspraak.

Stap 3: IComparable in Land

internal class Land : IComparable
{
    public int CompareTo(object obj)
    {
        Land temp = obj as Land;
        if (temp != null)
        {
            if (Oppervlakte > temp.Oppervlakte)
                return 1;
            if (Oppervlakte < temp.Oppervlakte)
                return -1;
            return 0;
        }
        else
            throw new ArgumentException(
                "Object is not a Land");
    }
}

Nu werkt Array.Sort(eurolanden);: het framework roept jouw CompareTo aan.

Opmerking

Zolang CompareTo ontbreekt: CS0535. Daarna blijft een groene kronkel CS8767 over het vraagteken in object?. Je code is correct, die mag je laten staan.

Beter sorteren

Gelijke oppervlakte? Dan op aantal inwoners:

if (Oppervlakte > temp.Oppervlakte) return 1;
if (Oppervlakte < temp.Oppervlakte) return -1;
if (this.Inwoners > temp.Inwoners) return 1;
if (this.Inwoners < temp.Inwoners) return -1;
return 0; //gelijke oppervlakte én inwoners

Tip

De bestaande datatypes hebben IComparable al ingebakken, ook string. Achteraan op Naam sorteren: return this.Naam.CompareTo(temp.Naam);

Een List sorteren

Ook hier moet je klasse IComparable hebben:

landLijst.Sort();

De lijst sorteert zichzelf: er komt geen nieuwe lijst terug.

Liever Array.Sort? Zet de lijst om met ToArray(). Array.Sort geeft niets terug, dus niet toewijzen:

Land[] landArray = landLijst.ToArray();
Array.Sort(landArray); //sorteert landArray zelf

Alles samen: polymorfisme, interfaces en is/as

Vloekende mensen

Mensen spreken. Enkel politiekers en advocaten hebben de interface IVloeker.

Klasse-schema vloekende mensen.
internal class Mens
{
    public void Spreek() { Console.WriteLine("Hoi!"); }
}
interface IVloeker { void Vloek(); }

internal class Leraar : Mens {}
internal class Student : Mens {}
internal class Politieker : Mens, IVloeker
{
    public void Vloek()
    {
        Console.WriteLine(
          "Godvermiljaardedju, zei de politieker");
    }
}
internal class Advocaat : Mens, IVloeker { ... }

Het probleem

Mens[] mensjes = new Mens[4];
mensjes[0] = new Leraar();
mensjes[1] = new Politieker();
mensjes[2] = new Student();
mensjes[3] = new Advocaat();
for (int i = 0; i < mensjes.Length; i++)
{
    //NOW WHAT?

Hoe laat je in deze array enkel de vloekers vloeken?

Oplossing 1 en 2

is to the rescue

if (mensjes[i] is IVloeker)
{
    IVloeker tijdelijk = (IVloeker)mensjes[i];
    tijdelijk.Vloek();
}
else
{
    mensjes[i].Spreek();
}

as to the rescue

IVloeker tijdelijk = mensjes[i] as IVloeker;
if (tijdelijk != null)
{
    tijdelijk.Vloek();
}
else
{
    mensjes[i].Spreek();
}

Oplossing 3: pattern matching

De moderne manier, wat je vandaag in echte code ziet:

for (int i = 0; i < mensjes.Length; i++)
{
    if (mensjes[i] is IVloeker vloeker)
    {
        vloeker.Vloek();
    }
    else
    {
        mensjes[i].Spreek();
    }
}

Slaagt de is-check, dan zit het object al klaar in vloeker: de harde cast uit oplossing 1 is niet meer nodig.

De black-box revelatie

Gedaan met je druk te maken over wat er allemaal in een klasse gebeurt.

Werk tegen de interfaces van een klasse.

En je krijgt de ultieme black-box revelatie. See what I did there?

Conclusie

Een interface is een belofte van publieke methoden en properties, zonder code

Een klasse die een interface draagt, moet alles ervan implementeren

Kies een interface voor “kan iets” en om er meerdere te combineren; een abstracte klasse voor gedeelde code en “is een”

Implementeer IComparable en Array.Sort of List.Sort sorteert je eigen objecten

Met is en as (en pattern matching) bevraag je objecten op een interface

Tip

Volgende halte: bestandsverwerking: lezen van en schrijven naar bestanden.

Meer weten

Kennisclips

Oefeningen H17 · Quizlet flashcards

Zie verder

Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.

Zie verder: zoek de fout

Onderstaande C#-klasse zou IComparable moeten implementeren zodat Array.Sort werkt, maar de compiler klaagt dat Land de interface niet volledig implementeert. Wat ontbreekt?

internal class Land : IComparable
{
    public string Naam { get; set; }
    public int Oppervlakte { get; set; }

    public int Vergelijk(object obj)
    {
        Land temp = obj as Land;
        return Oppervlakte.CompareTo(temp.Oppervlakte);
    }
}

Opmerking

De methode heet Vergelijk, maar IComparable vereist exact de methode CompareTo(object obj). Een interface is een belofte op de letter: de naam (en signatuur) moet precies kloppen. Hernoem Vergelijk naar CompareTo en de klasse compileert weer.

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf