Zie Scherp Scherper - Hoofdstuk 13
Na dit hoofdstuk kan je:
uitleggen wat overerving is en wanneer de is-een-relatie geldt
een child-klasse maken met de :-notatie
het protected-keyword en de regels rond private toepassen
begrijpen hoe constructors bij overerving samenwerken (base())
methoden aanpassen met virtual en override
de parent-implementatie hergebruiken met base
We deden al abstractie en encapsulatie. Nu: inheritance.
Programmeurs zijn lui
dubbele code = dubbel zoveel plekken voor bugs, en dubbel zoveel aan te passen
Hebben Monster en Held veel gemeen?
Dan delen ze wellicht een voorouder (Karakter)
De gemeenschappelijke code verhuist naar de parent; de child houdt enkel zijn specialisatie.
Tip
Dubbele code vermijden is eerder een gevolg van overerving dan het doel. Overerving komt terug bij polymorfisme, interfaces, …
parent-klasse
ook basisklasse of super-klasse
child-klasse
ook sub-klasse: een specialisatie van de parent
De child kan alles wat de parent kan, plus zijn eigen specialisatie.
“x is een y” wijst op overerving
een paard is een dier
een tulp is een plant
Kom je in een opgave is, was, zijn tegen, dan is overerving wellicht mogelijk.
Belangrijk
“x heeft een y” is géén overerving, maar associatie (volgend hoofdstuk).
Enkel bij een realistische “is een”-relatie pas je overerving toe.
Twee klassen met (bijna) dezelfde code hoeven dus niet van elkaar te erven.
Tip
Zelfs een taalkundig correcte “is een” geeft niet altijd goede overerving. Een vierkant is een rechthoek, en toch geeft Vierkant : Rechthoek vaak brokkelige code. Daar komen we op terug in hoofdstuk 16.
Een pijl van de child naar de parent.
Bij de mens en z’n voorgangers is elke soort een verbetering van de vorige:
Een Paard kan alles wat een Dier kan, plus zijn eigen specialisatie:
De child erft alles
methoden properties instantievariabelen
Een Villa is een Huis, en een Huis is een Gebouw. Een Villa-object heeft dus ook alles van Gebouw in zich.
Ook private instantievariabelen worden overgeërfd, maar de child-code kan er niet aan.
Staat in Huis een private bool heeftDeurbel, dan kan enkel code in Huis die bool gebruiken. Code in Villa niet.
Met private lukt dit niet:
Tip
Veiliger: een property met protected set. De buitenwereld kan enkel lezen, de klasse en haar children mogen instellen.
public int Geboortejaar { get; protected set; }
In C# erft een klasse van maximaal één parent. Een Mens die tegelijk erft van Aap en van Tekening? Kan niet.
Dat vermijdt het diamond problem: erf je van twee parents met dezelfde methode, welke moet de compiler dan gebruiken?
Meerdere “rollen” combineren doe je met interfaces (hoofdstuk 17)
Tip
In de echte wereld kom je multiple inheritance bijna nooit tegen. Het typische tegenvoorbeeld is het vogelbekdier, maar hoe vaak ga je dat modelleren? Meestal zijn compositie en interfaces de oplossing.
Wil je verhinderen dat iemand van je klasse erft? Zet er sealed voor:
'ChildClass': cannot derive from sealed type 'DoNotInheritMe'Maak je een child-object, dan lopen de constructors in volgorde:
1. eerst de verste voorouder
bovenaan de keten
2. dan elke tussenliggende parent
3. ten slotte de klasse zelf
Tip
Logisch: de child heeft de fundering van zijn parent nodig voor hij zelf iets kan doen.
Hier gaat C# ervan uit dat Soldaat een default constructor heeft.
Achter elke child-constructor staat impliciet : base(): “roep de default constructor van de parent aan”.
Belangrijk
Heeft Soldaat enkel een overloaded constructor Soldaat(bool kanSchieten), dan bestaat er geen default constructor meer. new VeldArts() compileert dan niet, tot je zelf de juiste base(...) aanroept.
De formele parameter kanSchieten gaat als actuele parameter naar base. De default constructor zet hem altijd op true.
internal class Gebouw
{
public int AantalVerdiepingen { get; private set; }
public Gebouw(int verdiepingenIn) { AantalVerdiepingen = verdiepingenIn; }
}
internal class Huis : Gebouw
{
public bool HeeftTuintje { get; private set; }
public Huis(bool heeftTuin, int aantalVer) : base(aantalVer)
{
HeeftTuintje = heeftTuin;
}
}new Huis(true, 1): de child houdt heeftTuin zelf, en sluist aantalVer door naar de parent.
new Huis(true, 5):
Huis startbase(5) aanGebouw zet AantalVerdiepingenHuis: HeeftTuintje = trueSoms wil je in de child:
een methode van de parent uitbreiden
een methode of property volledig herschrijven
De parent moet dat toelaten met virtual. De child gebruikt override.
Tip
virtual is een mogelijkheid, geen verplichting. Je hoeft niet elk virtueel element te overriden.
virtual staat in de signatuur, los van zichtbaarheid en returntype. Ook dit mag:
protected virtual int SayWhatNow()
Belangrijk
virtual kan op alles behalve private (de child ziet het niet). Ook static methoden kunnen niet virtual.
Zonder de override toont dit twee keer de vliegtuig-zin. Met:
De override van Raket vervangt de virtual versie van Vliegtuig.
Tip
De signatuur van de override is identiek aan die van de parent: enkel virtual wordt override. In VS typ je override, en de tab-toets vult de rest aan.
Waarschuwing
Schrijf je in de child gewoon public void Vlieg(), zonder override, dan compileert het wel, maar krijg je een waarschuwing dat je het new-keyword zou moeten gebruiken.
C# denkt dan dat je de parent-methode wil verbergen (hiding), niet overschrijven (overriding). Roep je de methode aan via een parent-referentie, dan draait toch de oude parent-versie.
Krijg je die new-waarschuwing? Dan ben je vermoedelijk override vergeten.
Er moet een ReddingsHelikopter bij. De A.I. gaf hem dit:
“Helikopter gebruikt netjes override, dus dit toont mijn reddingshelikopter-versie”, zegt hij.
Opmerking
In ReddingsHelikopter staat new in plaats van override. Zo verbergt Steven de methode van Helikopter, hij overschrijft ze niet. De aanroep gebeurt via een Helikopter-referentie, dus draait de versie van Helikopter.
Dat Helikopter zelf wél correct override gebruikt, verandert daar niets aan: elke stap in de hiërarchie moet zijn eigen override zetten.
Verandert de basisprijs in Restaurant, dan moet je ook alle child-klassen aanpassen.
Met base roep je in een override toch de parent-versie aan:
De basislogica staat op één plek. Hetzelfde base zag je al bij de constructors.
Tip
Waar je base aanroept, kies je zelf: aan de start, op het einde of halverwege de methode.
Maak Update in Balletje virtual en bouw een balletje dat naar het midden teleporteert:
Balletje blijft onaangeroerd; in het hoofdprogramma vervang je Balletje door CentreerBalletje. Dankzij polymorfisme (hoofdstuk 16) mag straks zelfs Balletje bal1 = new CentreerBalletje();.
Overerving geldt bij een echte is-een-relatie; de child specialiseert de parent
De child erft alles, maar private blijft afgeschermd; protected opent het voor children
Constructors lopen van parent naar child; met base() kies je de juiste parent-constructor
virtual + override laten een child de werking aanpassen; zonder override krijg je hiding
Met base hergebruik je de parent-implementatie binnen een override
Tip
Volgende halte: gevorderde overerving: System.Object, abstract en eigen exceptions.
Kennisclips
Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.
Onderstaande C#-code wil de poetskost van een frituur correct berekenen. Een Restaurant poetsen kost 1000, een Frituur heeft daarbovenop 500 ontsmetting nodig. Toch komt er een fout uit. Wat loopt er mis?
Opmerking
PoetsAlles in Restaurant staat niet als virtual gemarkeerd, dus de override in Frituur geeft een compileerfout. Zet public virtual void PoetsAlles() in Restaurant, dan mag de child de methode overschrijven.
Alles uit dit hoofdstuk op één A4.