Zie Scherp Scherper - Hoofdstuk 17
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
“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.
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
I interface in plaats van class, naam start met een I
public Geen public (alles is publiek)
; Geen code: elke signatuur eindigt op ;
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.
| 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.
Steven laat een Fiets de interface IVoertuig implementeren:
“Een abstracte klasse liet me toch ook methoden ongemoeid?” Waarom weigert de compiler hier?
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.
Zolang Zorro niet alles uit ISuperHeld implementeert, compileert de klasse niet.
Overerven én meerdere interfaces mag ook: internal class DarthVader : StarWarsCharacter, IForceUser, IPilot
Een “lolly” op een klasse geeft aan dat ze een interface heeft. Hier heeft WerkStudent de interface IVerkortTraject:
Interface UML notatie.
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.
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.
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…”.
Boek implementeert IVerwijderbaar, Persoon niet:
De kracht zie je pas in een lijst met een allegaartje aan objecten:
Een klasse erft van maar één parent, maar mag meerdere interfaces dragen:
Tip
De volgorde is belangrijk: eerst de klasse waarvan je overerft, dan pas de interface(s).
Een nieuwe interface die álles van een bestaande moet kunnen, plus wat extra:
Wie IGod implementeert, moet dus ook alle methoden van ISuperHeld voorzien.
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.
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.
De CEO blijft zijn bestaande job doen, maar kan nu ook minister zijn.
Interfaces, compositie en polymorfisme samen: eender wie kan minister worden zonder zijn job op te zeggen.
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.
We willen landen sorteren op oppervlakte:
Opmerking
Logisch: .NET weet niet hoe het een Land moet sorteren. Alfabetisch op Naam? Op Inwoners? Enkel jij weet het.
De interface uit de documentatie:
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.
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.
Gelijke oppervlakte? Dan op aantal inwoners:
Tip
De bestaande datatypes hebben IComparable al ingebakken, ook string. Achteraan op Naam sorteren: return this.Naam.CompareTo(temp.Naam);
Ook hier moet je klasse IComparable hebben:
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:
Mensen spreken. Enkel politiekers en advocaten hebben de interface IVloeker.
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 { ... }Hoe laat je in deze array enkel de vloekers vloeken?
De moderne manier, wat je vandaag in echte code ziet:
Slaagt de is-check, dan zit het object al klaar in vloeker: de harde cast uit oplossing 1 is niet meer nodig.
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?
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.
Kennisclips
Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.
Onderstaande C#-klasse zou IComparable moeten implementeren zodat Array.Sort werkt, maar de compiler klaagt dat Land de interface niet volledig implementeert. Wat ontbreekt?
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.
Alles uit dit hoofdstuk op één A4.