Wat leer je in dit hoofdstuk?

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

Inheritance: de I van A PIE

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, …

Wat is overerving?

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.

De is-een relatie

“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.

In UML: een pijl van child naar parent.

Belangrijk

“x heeft een y” is géén overerving, maar associatie (volgend hoofdstuk).

Gelijkaardige code is nog geen overerving

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.

Overerving in UML

Een pijl van de child naar de parent.

Bij de mens en z’n voorgangers is elke soort een verbetering van de vorige:

  • homo habilis
  • homo erectus
  • homo sapiens sapiens

Overerving van onze soort.

Overerving in C#

internal class Dier
{
    public void Eet() { /* ... */ }
}

internal class Paard : Dier
{
    public bool KanHinnikken { get; set; }
}

Een Paard kan alles wat een Dier kan, plus zijn eigen specialisatie:

Dier aDier = new Dier();
Paard bPaard = new Paard();
aDier.Eet();
bPaard.Eet();                // van Dier
bPaard.KanHinnikken = false; // van Paard
aDier.KanHinnikken = false;  // !!! werkt niet

Alles wordt overgeërfd

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.

Villa, Huis en Appartement zijn een Gebouw.

Overerving en het geheugen

Huis eenHuis = new Huis();
Villa groteVilla = new Villa();

Een object is opgebouwd uit een parent-deel plus zijn eigen specialisatie.

Een Huis en een Villa in het geheugen.

Private blijft private

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.

Private is echt private.

protected

Met private lukt dit niet:

internal class Paard : Dier
{
    public void MaakOuder()
    {
        geboortejaar++; // error!
    }
}
internal class Dier
{
    private int geboortejaar;
}

Met protected wel: zichtbaar in de klasse én in haar children.

internal class Dier
{
    protected int geboortejaar;
}

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; }

Geen multiple inheritance

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.

sealed

Wil je verhinderen dat iemand van je klasse erft? Zet er sealed voor:

internal sealed class DoNotInheritMe
{
    //...
}

internal class ChildClass : DoNotInheritMe // fout!
{
    //...
}
'ChildClass': cannot derive from sealed type 'DoNotInheritMe'

Constructors bij overerving

De constructor-keten

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.

Eerst de parent, dan de child

internal class Soldaat
{
    public Soldaat()
    {
        Console.WriteLine("Soldaat is aangemaakt.");
    }
}

internal class VeldArts : Soldaat
{
    public VeldArts()
    {
        Console.WriteLine("Veldarts is aangemaakt.");
    }
}
VeldArts RexGregor = new VeldArts();
Soldaat is aangemaakt.
Veldarts is aangemaakt.

Hier gaat C# ervan uit dat Soldaat een default constructor heeft.

base()

Achter elke child-constructor staat impliciet : base(): “roep de default constructor van de parent aan”.

public VeldArts() : base()
{
    Console.WriteLine("Veldarts is aangemaakt.");
}

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.

base() met parameters

internal class Soldaat
{
    public Soldaat(bool kanSchieten) { /* soldaten dingen */ }
}

internal class VeldArts : Soldaat
{
    public VeldArts(bool kanSchieten) : base(kanSchieten)
    { }

    public VeldArts() : base(true) // default
    {
        Console.WriteLine("Veldarts is aangemaakt.");
    }
}

De formele parameter kanSchieten gaat als actuele parameter naar base. De default constructor zet hem altijd op true.

Parameters doorgeven via base

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.

De volgorde in beeld

new Huis(true, 5):

  1. constructor Huis start
  2. roept eerst base(5) aan
  3. Gebouw zet AantalVerdiepingen
  4. terug in Huis: HeeftTuintje = true

Constructor-flow bij overerving.

Virtual en Override

De werking van de parent aanpassen

Soms 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: vliegende objecten

internal class Vliegtuig
{
    public virtual void Vlieg()
    {
        Console.WriteLine("Het vliegtuig vliegt door de wolken.");
    }
}
internal class Raket : Vliegtuig
{
}

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.

override: de raket vliegt anders

internal class Raket : Vliegtuig
{
    public override void Vlieg()
    {
        Console.WriteLine("De raket verdwijnt in de ruimte.");
    }
}
Vliegtuig topGun = new Vliegtuig();
Raket spaceX1 = new Raket();
topGun.Vlieg();
spaceX1.Vlieg();

Zonder de override toont dit twee keer de vliegtuig-zin. Met:

Het vliegtuig vliegt door de wolken.
De raket verdwijnt in de ruimte.

Dezelfde aanroep, ander resultaat

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.

override vergeten? Hiding

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.

Stagiair Steven

Er moet een ReddingsHelikopter bij. De A.I. gaf hem dit:

internal class Helikopter : Vliegtuig
{
    public override void Vlieg()
    {
        Console.WriteLine("De helikopter hangt stil in de lucht.");
    }
}
internal class ReddingsHelikopter : Helikopter
{
    public new void Vlieg()
    {
        Console.WriteLine(
            "De reddingshelikopter scheert laag over het water.");
    }
}
Helikopter redder = new ReddingsHelikopter();
redder.Vlieg();

“Helikopter gebruikt netjes override, dus dit toont mijn reddingshelikopter-versie”, zegt hij.

Stagiair Steven: wat liep er mis?

De helikopter hangt stil in de lucht.

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.

Het base keyword

Zonder base: een slecht idee

internal class Restaurant
{
    protected int kosten = 0;
    public virtual void PoetsAlles()
    {
        kosten += 1000;
    }
}
internal class Frituur : Restaurant
{
    public override void PoetsAlles()
    {
        kosten += (1000 + 500); // SLECHT IDEE!
    }
}

Verandert de basisprijs in Restaurant, dan moet je ook alle child-klassen aanpassen.

base in een methode

Met base roep je in een override toch de parent-versie aan:

internal class Frituur : Restaurant
{
    public override void PoetsAlles()
    {
        base.PoetsAlles();  // eerst de basiskost
        kosten += 500;      // dan de kost eigen aan de frituur
    }
}

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.

“Ik heb een extra voorbeeldje nodig”

internal class Oermens
{
    public virtual int VoorzieVoedsel()
    {
        return 15; //kg
    }
}
internal class ModerneMens : Oermens
{
    public bool IsJager { get; set; }

    public override int VoorzieVoedsel()
    {
        if (IsJager)
            return base.VoorzieVoedsel() + 20;
        return 100;
    }
}

Moderne mens: 100 kg. Een jager gebruikt de techniek van de Oermens (base, 15 kg) plus 20 kg.

Pong met overerving

Maak Update in Balletje virtual en bouw een balletje dat naar het midden teleporteert:

internal class CentreerBalletje : Balletje
{
    public override void Update()
    {
        if (X + VX >= Console.WindowWidth || X + VX < 0)
        {
            X = Console.WindowWidth / 2;
            Y = Console.WindowHeight / 2;
        }
        base.Update();
    }
}

Balletje blijft onaangeroerd; in het hoofdprogramma vervang je Balletje door CentreerBalletje. Dankzij polymorfisme (hoofdstuk 16) mag straks zelfs Balletje bal1 = new CentreerBalletje();.

Conclusie

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.

Meer weten

Kennisclips

Oefeningen H13 · 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#-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?

internal class Restaurant
{
    protected int kosten = 0;
    public void PoetsAlles()
    {
        kosten += 1000;
    }
}
internal class Frituur : Restaurant
{
    public override void PoetsAlles()
    {
        base.PoetsAlles();
        kosten += 500;
    }
}

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.

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf