Virtual en Override

Soms willen we aangeven dat de implementatie (code) van een property of methode in een parent-klasse door child-klassen mag aangepast worden. Dit geven we aan met het virtual keyword:

Stel dat we 2 objecten aanmaken en laten vliegen:

Vliegtuig f1 = new Vliegtuig();
Raket spaceX1 = new Raket();
f1.Vlieg();
spaceX1.Vlieg();

De uitvoer zal dan zijn:

Een raket is een vliegtuig, toch vliegt het anders. We willen dus de methode Vlieg anders uitvoeren voor een raket. Daar hebben we override voor nodig. Door override voor een methode in de child-klasse te plaatsen zeggen we "gebruik deze implementatie en niet die van de parent klasse." Je kan enkel overriden indien de respectievelijke methode of property in de parent-klasse als virtual werd aangeduid

De uitvoer van volgende code zal nu anders zijn:

Uitvoer:

Properties overriden

Ook properties kan je virtual instellen en override'n.

Opgelet: Visual Studio gebruikt Expression Body Member syntax (herkenbaar aan de =>) om properties te overriden. Deze syntax kennen we niet (lees er gerust meer over ). Je schrijft dus best manueel de override van properties

Stel dat je volgende klasse hebt:

We maken nu een meer luxueuze auto die een lichtje heeft dat aangaat wanneer de benzine-tank vol genoeg is, dit kan via override.

Kennisclip

Het base keyword laat ons toe om bij een overriden methode of property in de child-klasse toch te verplichten om de parent-implementatie toe te passen.

Stel dat we volgende 2 klassen hebben:

class Restaurant
{
     protected int kosten=0;
     public virtual void PoetsAlles()
     {
           kosten+=1000;
     }
}

class Frituur:Restaurant
{
     public override void PoetsAlles()
     {
           kosten+= (1000 + 500);
     }

}

Het poetsen van een Frituur is duurder (1000 basis + 500 voor ontsmetting) dan een gewoon restaurant. Als we echter later beslissen dat de basisprijs (in Restaurant) moet veranderen dan moet je ook in alle child-klassen doen. Base lost dit voor ons. De Frituur-klasse herschrijven we naar:

class Frituur:Restaurant
{
     public override void PoetsAlles()
     {
           base.PoetsAlles(); //eerste basiskost wordt opgeteld
           kosten+=500;  //kosten eigen aan frituur worden bijgeteld.
     }

}

Constructors bij overerving

Wanneer je een object instantiëert van een child-klasse dan gebeuren er meerdere zaken na elkaar, in volgende volgorde:

• Eerst wordt de constructor aangeroepen van de basis-klasse: dus steeds eerst die van System.Object

• Gevolgd door de constructors van alle parent-klassen

• Finaal de constructor van de klasse zelf.

Volgende voorbeeld toont dit in actie:

Indien je vervolgens een object aanmaakt van het type Medic:

Dan zal zien we de volgorde van constructor-aanroep op het scherm:

Er wordt dus verondersteld in dit geval dat er een default constructor in de basis-klasse aanwezig is.

Overloaded constructors

Indien je klasse Soldier een overloaded constructor heeft, dan geeft deze niet automatisch een default constructor. Volgende code zou dus een probleem geven indien je een Medic wilt aanmaken via new Medic():

Wat je namelijk niet ziet bij child-klassen en hun constructors is dat er eigenlijk een impliciete call naar de basis-constructor wordt gedaan. Bij alle constructors staat eigenlijk :base() wat je ook zelf kunt schrijven:

base() achter de constructor zegt dus eigenlijk 'roep de constructor van de parent-klasse aan. Je mag hier echter ook parameters meegeven en de compiler zal dan zoeken naar een constructor in de basis-klasse die deze volgorde van parameters kan accepteren.

We zien hier dus hoe we ervoor moeten zorgen dat we terug Medics via new Medic() kunnen aanroepen zonder dat we de constructor(s) van Soldier moeten aanpassen:

De medics zullen de canShoot dus steeds op true zetten. Uiteraard wil je misschien dit kunnen meegeven bij het aanmaken van een object zoals new Medic(false), dit vereist dat je dus een overloaded constructor in Medic aanmaakt, die op zijn beurt de overloaded constructor van Soldier aanroept. Je schrijft dan een overloaded constructor in Medic bij:

Uiteraard mag je ook de default constructor aanroepen vanuit de child-constructor, alle combinaties zijn mogelijk (zolang de constructor in kwestie maar bestaat in de parent-klasse).

Kennisclip

*

Overerving

Overerving (inheritance) laat ons toe om klassen te specialiseren vanuit een reeds bestaande basisklasse. Wanneer we een klasse van een andere klasse overerven dan zeggen we dat deze nieuwe klasse een child-klasse of sub-klasse is van de bestaande parent-klasse of super-klasse.

De child-klasse kan alles wat de parent-klasse kan, maar de nieuwe klasse kan nu ook extra specialisatie code krijgen.

Is-een relatie

Wanneer twee klassen met behulp van een "x is een y"-relatie kunnen beschreven worden dan weet je dat overerving mogelijk.

• Een paard is een dier (paard = child-klasse, dier= parent-klasse)

• Een tulp is een plant

Inheritance in CS

Overving duid je aan met behulp van het dubbele punt(:) bij de klassedefinitie:

Een voorbeeld:

Objecten van het type Dier kunnen enkel de Eet-methode aanroepen. Objecten van het type Paard kunnen de Eet-methode aanroepen én ze hebben ook een property KanHinnikken:

Multiple inheritance

In C# is het niet mogelijk om een klasse van meer dan een parent-klasse te laten overerven (zogenaamde multiple inheritance), wat wel mogelijk is in sommige andere object georiënteerde talen.

Transitive

Overerving in C# is transitief, dit wil zeggen dat de child-klasse niet alleen overerft van haar ouderklasse, maar ook van grootouderklassen enzovoort. Je zou bijvoorbeeld een subklasse Pony van de klasse Paard kunnen toevoegen. Een Pony is een Paard en een Paard is een Dier, dus een Pony is ook een Dier en heeft bijvoorbeeld een methode Eet.

Protected

Ook al heeft een subklasse alle onderdeeltjes van een ouderklasse, hou er rekening mee dat private variabelen en methoden van de parent-klasse NIET rechtsreeks aanroepbaar zijn in de child-klasse. Private betekent namelijk: "enkel toegankelijk binnenin deze klasse". Private geeft aan dat het element enkel in de klasse zichtbaar is:

Een Paard heeft nog wel een leeftijd, maar binnenin de code voor de klasse Paard kan je de leeftijd niet zomaar opvragen of aanpassen.

Je kan dit oplossen door de protected access modifier ipv private te gebruiken. Met protected geef je aan dat het element enkel zichtbaar is binnen de klasse en binnen child-klassen:

Sealed

Soms wil je niet dat van een klasse nog nieuwe klasse kunnen overgeërfd worden. Je lost dit op door het keyword sealed voor de klasse te zetten:

Als je later dan dit probeert:

zal dit resulteren in een foutoodschap, namelijk cannot derive from sealed type 'DoNotInheritMe'.

Kennisclip

Een bestaande klasse uitbreiden via overerving

Leerdoelen

• overerving van bestaande klassen laten zien

• toegang tot properties en methodes demonstreren

Functionele analyse

Maak een nieuwe klasse, WorkingStudent. Een werkstudent verschilt van een student omdat hij soms moet gaan werken en omdat hij een bepaald aantal werkuren per week moet presteren.

Technische analyse

Deze klasse erft over van de klasse Student die je voor het eerst hebt gebruikt in hoofdstuk 8.

Bovenop alle eigenschappen / methoden van Student heeft WorkingStudent:

• een methode HasWorkToday() die willekeurig true of false teruggeeft. Er is geen methode NextBool in de klasse random, maar je kan een willekeurig getal tussen 0 en 1 genereren en de uitkomst vertalen in een boolean.

• een property WorkHours die een aantal gepresteerde uren bijhoudt (als byte

Voeg een statische methode DemonstrateWorkingStudent() toe aan je klasse voor deze les. Deze methode doet volgende zaken:

• ze maakt met de default constructor één gewone student aan (de properties mag je invullen zoals je zelf wil, maar vul ze wel in)

• ze maakt met de default constructor één werkstudent aan (de properties mag je invullen zoals je zelf wil, maar vul ze wel in)

• ze plaatst beide in een List<Student>

Klassen met aangepaste constructor maken

Functionele analyse

We schrijven een applicatie die een lijst van af te handelen taken bijhoudt. Er zijn twee soorten taken: éénmalige taken en terugkerende taken. Elke taak heeft een beschrijving, maar terugkerende taken hebben ook een bepaalde hoeveelheid tijd waarna ze herhaald moeten worden.

Technische analyse

• Maak een klasse Task met een property Description en een constructor die een waarde voor deze beschrijving verwacht (een string).

  • Wanneer deze constructor wordt opgeroepen, wordt volgende tekst getoond: "Taak is aangemaakt." Je vult hier zelf de beschrijving van de taak in.

Voorbeeldinteractie

Oefening: H12-ziekenhuis

Leerdoelen

• werken met methodes

• methodes overschrijfbaar maken

• code specifieker maken met behulp van subklassen

Functionele analyse

Dit programma berekent de doktersrekening van een patiënt, op basis van een basisbedrag (€50) en een extra kost (€20/uur). In het geval van een verzekerde patiënt worden de kosten met 10% verlaagd.

Technische analyse

• Schrijf twee klassen: Patient en InsuredPatient

• Beide hebben als properties een naam (een string) en een verblijfsduur (een uint)

voorbeeldinteractie

Testscenario's

• Test ook uit met een verblijf van 1 uur.

• Test ook uit met een verblijf van 0 uur.

• Test ook uit met de patiënten beschreven in de voorbeeldinteractie.

Oefening: dynamic dispatch

Leerdoelen

• herbruik code ouderklasse

• virtual, override, base

Functionele analyse

Onze rapporten van studenten missen belangrijke informatie. We willen te zien krijgen wie het statuut van werkstudent heeft.

Technische analyse

Pas je klassen Student en WorkingStudent aan, zodat de bestaande methode ShowOverview een uitgebreider overzicht toont voor werkstudenten (voor gewone studenten blijft het ongewijzigd). Dit heeft dan de vorm:

De laatste twee regels komen bovenop de info die je eerder al toonde. Maak gebruik van base zodat je niet de volledige implementatie opnieuw hoeft te schrijven. Pas nu je methode DemonstrateWorkingStudent aan zodat niet de naam van elke student in de lijst wordt getoond, maar zodat zijn volledig rapport wordt getoond.