Wat leer je in dit hoofdstuk?

Na dit hoofdstuk kan je:

het verschil tussen compositie en aggregatie uitleggen

de heeft-een-relatie herkennen (tegenover de is-een-relatie)

een object als instantievariabele, via de constructor of via een property in een klasse plaatsen

een heeft-meerdere-relatie modelleren met een array of List

afwegen wanneer je associatie boven overerving kiest

het this-keyword gebruiken

Tip

Eigenlijk niets nieuws: je deed dit waarschijnlijk al, zonder de naam te kennen.

Associaties: twee smaken

Een object in een ander object gebruiken heet een associatie.

Het verschil zit in de levensduur van het interne object (de motor in de auto, de schijf in de computer):

Compositie (composition)

het interne object heeft geen bestaansreden zonder het omliggende

verdwijnt het huis, dan ook de kamer

Aggregatie (aggregation)

beide kunnen op zichzelf bestaan

de motor van een vernielde auto kan je elders gebruiken

Heeft een-relatie

Is een of heeft een?

Overerving = is een

“een paard is een dier”

Associatie = heeft een

“een mango heeft een pit”, “een vliegtuig heeft een cockpit”

Je hoort meteen of het om heeft één of heeft meerdere gaat. Een boek heeft meerdere pagina’s: in Boek staat dus een Pagina[] of List<Pagina>.

Belangrijk

Klassieke fout: overerving tussen een boek en z’n pagina’s. Een boek is geen pagina. Een boek heeft pagina’s: aggregatie (een uitgescheurde pagina kan je nog doorgeven).

Compositie en aggregatie in UML

Compositie: een lijn met een volle ruit aan de kant van de klasse die de objecten in zich heeft.

Een huis heeft een slaap- en badkamer.

Aggregatie: dezelfde lijn, met een lege ruit. Optioneel staan er getallen aan de uiteinden.

Een computer heeft 1 tot 8 processoren.

Tip

Ter herinnering: overerving is een pijl naar de parent-klasse.

De getallen lezen

Een getal staat telkens aan de kant van de klasse waarover het gaat:

1 precies één

1..8 minstens 1, hoogstens 8 processoren

0..4 0 tot 4 harde schijven: nul mag ook

0..1 hoogstens één, of geen: met of zonder geluidskaart

De 1 aan de kant van Computer zegt dat elk onderdeel bij één computer hoort.

Combinaties

Een reeks huizen, met in elke slaapkamer een computer:

  • de kamers horen bij het huis: compositie
  • de computer niet: aggregatie

Een computer kan je uit een brandend huis redden. De kamers van het huis zelf helaas niet.

In code: een object als instantievariabele

Een PC heeft een HardeSchijf, dus zit er in PC een instantievariabele van het type HardeSchijf:

internal class PC
{
    private HardeSchijf cHardeSchijf;
}

Vergeet niet die HardeSchijf ook te instantiëren, anders blijft hij de hele levensduur van elke PC null.

Tip

Er is geen vaste oplossingsstrategie: welke manier je kiest, hangt af van je probleem. Hierna volgen er drie.

Manier 1 en 2: compositie

Meteen bij de instantievariabele, of via de constructor:

internal class PC
{
    private HardeSchijf cHardeSchijf = new HardeSchijf();   // manier 1

    public PC(bool preinstallHD)                             // manier 2
    {
        //enkel interne harde schijf als de klant dat wenst
        if (preinstallHD)
            cHardeSchijf = new HardeSchijf();
        else
            cHardeSchijf = null;
    }
}

Sterft de PC, dan sterft de interne schijf mee: dat is compositie.

Waarom expliciet null?

cHardeSchijf = null is niet nodig: zonder de if blijft hij sowieso null.

Toch schrijf je het best expliciet. Je zegt daarmee: “zonder preinstallatie zit er geen harde schijf in de pc”. En had iets anders er intussen toch een schijf in gestoken, dan is die nu zeker weg.

Tip

Merk op hoe we over preinstallatie praten alsof het echt gebeurt. OOP laat je de realiteit zo dicht mogelijk benaderen. Kijk eens rond je en vertaal wat je ziet naar klassen, objecten en hun verbanden.

Manier 3: aggregatie via property

Maak het object buiten de PC aan en steek het erin via een property:

internal class PC
{
    public HardeSchijf CHardeSchijf { get; set; }
}
HardeSchijf mijnHardeSchijf = new HardeSchijf();
PC mijnPC = new PC();
mijnPC.CHardeSchijf = mijnHardeSchijf;

Er blijft een externe referentie (mijnHardeSchijf), dus de GC ruimt de schijf niet op met de PC: dat is aggregatie.

Het interne object gebruiken

Heeft HardeSchijf een auto-property MaxCapacity, dan kan PC die gewoon gebruiken:

internal class PC
{
    private HardeSchijf cHardeSchijf = new HardeSchijf();
    public override string ToString()
    {
        return $"PC capaciteit HD: {cHardeSchijf.MaxCapacity} Gb";
    }
}

Tip

Niets nieuws onder de zon. Het verschil met een value type (zoals int geboortejaar): een object moet je eerst instantiëren, dus controleer je vaker op null.

In het geheugen

PC mijnSuperPC = new PC();

Het interne object staat apart in de heap; de PC bewaart enkel een referentie ernaar.

Compositie geeft dus geen groot object waarin alles samen zit.

Stel je altijd zo’n tekening voor: waar leven de referenties, en wanneer ruimt de GC iets op?

NullReferenceException

Een intern object aanspreken dat nooit werd aangemaakt: een klassieke fout. Controleer op null telkens je het gebruikt:

public override string ToString()
{
    string result = "Dit is een Intel i9.";
    if (cHardeSchijf != null)
        result += $"Capaciteit HD: {cHardeSchijf.MaxCapacity} Gb";
    else
        result += "Er is geen harde schijf aanwezig";
    return result;
}

Opmerking

Alles in try-catch steken is op detailniveau niet werkbaar. Schrijf je code van bij de start met null-controles.

Heeft-meerdere relatie

Een boek heeft veel pagina’s, dus een array:

internal class Boek
{
    public Pagina[] AllePaginas { get; set; } = new Pagina[100];
    public void InsertPagina(Pagina paginaIn, int positie)
    {
        AllePaginas[positie] = paginaIn;
    }
}
Boek zieScherper = new Boek();
Pagina mijnDerdePagina = new Pagina();
zieScherper.InsertPagina(mijnDerdePagina, 2);

Ook de individuele elementen moet je nog instantiëren.

Met een List: niet zo

internal class Boek
{
    //SLECHT IDEE!
    public List<Pagina> AllePaginas { get; set; } = new List<Pagina>();
}
zieScherper.AllePaginas.Insert(5, new Pagina());

Handig, want je krijgt Insert cadeau. Maar wie jouw Boek gebruikt, moet nu weten dat er intern een List zit.

Belangrijk

Je wil een blackbox: van buiten duidelijk en eenvoudig in gebruik.

Een eigen Insert-methode

internal class Boek
{
    public List<Pagina> AllePaginas { get; private set; } = new List<Pagina>();

    public void InsertPagina(Pagina paginaIn, int positie)
    {
        AllePaginas.Insert(positie, paginaIn);
    }
}
zieScherper.InsertPagina(new Pagina(), 5);

Met de private set kan niemand van buitenaf een nieuwe lijst in het boek steken.

Belangrijk

Mag AllePaginas nooit leeg zijn? Via een publieke property kan iemand zomaar Clear() aanroepen. Of die private set daar iets aan verandert, zoekt Steven uit.

Stagiair Steven

Steven paste de tip toe en zette de setter van AllePaginas op private, met een InsertPagina-methode erbij.

“private set erop, dus niemand kan AllePaginas nog van buitenaf stukmaken”, zegt hij zelfverzekerd.

Elders in de code staat echter:

zieScherper.AllePaginas.Clear();

Werkt deze regel, ondanks de private set?

Stagiair Steven: wat liep er mis?

Opmerking

Ja, deze regel werkt en maakt het boek leeg. private set verbiedt enkel dat iemand een nieuwe lijst toekent (zieScherper.AllePaginas = ... geeft nu een compilerfout).

De get bleef public en geeft de échte lijst terug, geen kopie. Clear(), Add() en Remove() zijn methoden op de lijst zelf, geen toekenning aan de property.

private set beschermt tegen het vervangen van de lijst, niet tegen het muteren ervan.

Associatie of overerving?

Favor composition over inheritance.

twijfel je of een “is een”-relatie klopt, kies dan “heeft een”

In de praktijk gebruik je veel vaker een heeft-een dan een is-een-relatie. Met associatie laat je totaal verschillende zaken samenwerken, ook zonder “is een”.

Alles kan een compositie-object zijn: een Dictionary van klanten in een Winkel, de organen in een Mens.

De Mens-simulator

Een patiënt krijgt via een property (manier 3) een nieuw hart:

Mens patient = new Mens();
Mens donor = new Mens();
//Donor heeft een tragisch ongeluk en sterft
//Operatie start
patient.Hart = null; //vorig hart wordt "verwijderd"
patient.Hart = donor.Hart;
donor = null; //donor wordt begraven

Belangrijk

patient.Hart = donor.Hart; kopieert niet: beide verwijzen naar hetzelfde Hart-object. Een object delen is niet hetzelfde als een object kopiëren.

Geen Dokter Frankenstein

Belangrijk

Pas niet overal compositie toe alsof je de Dokter Frankenstein van C# bent. Hoe meer compositie of aggregatie in een klasse, hoe specifieker ze wordt, en dus mogelijk minder herbruikbaar.

Tip

Daarom ontdekken we straks interfaces: zo zitten klassen minder “op elkaar gelijmd”.

Het this keyword

this: drie toepassingen

this geeft de referentie naar het huidige object.

een object kan zichzelf meegeven als actuele parameter

een instantievariabele of property aanroepen die dezelfde naam heeft als een lokale variabele

een andere constructor aanroepen, zoals in hoofdstuk 11: public Werknemer() : this(1)

Belangrijk

this werkt enkel in een instance-context (gewone methoden, properties, constructors). In een static methode bestaat er geen “huidig object”.

this.: alles van de klasse

Typ je this. in een klasse, dan zie je de volledige interne structuur, ongeacht de access modifiers.

Je mag this altijd gebruiken om iets van de klasse zelf te bereiken. In oudere code zie je dat vaak.

Met this zie je alles wat de klasse aanbiedt.

this: naamconflict oplossen

public Speler(int Levens)
{
    Levens = 5;      // de parameter
    this.Levens = 5; // de property
}

Levens = 5; past de parameter aan (niet aangeraden). Met this geraak je aan de property met dezelfde naam.

this bij conflicterende namen.

Tip

Levens als naam voor de parameter is sowieso een ongelukkige keuze.

this: zichzelf meegeven

internal class Management
{
    private const int MAXRANG = 10;
    public static bool MagPromoveren(Werknemer toCheck)
    {
        return toCheck.Rang < MAXRANG;
    }
}
internal class Werknemer
{
    public int Rang { get; set; }
    public bool IsPromoveerbaar()
    {
        return Management.MagPromoveren(this);
    }
}

Het object geeft zichzelf (this) mee aan Management.MagPromoveren(). Zo weet een werknemer zelf of hij kan promoveren:

Werknemer francis = new Werknemer();
if (francis.IsPromoveerbaar())
{
    Console.WriteLine("Jeuj!");
}

Conclusie

Een associatie is een object-in-een-object; compositie (sterft mee) of aggregatie (los leefbaar)

De heeft-een-relatie wijst op associatie, de is-een-relatie op overerving

Plaats het interne object via een instantievariabele, constructor of property, en controleer op null

“Heeft meerdere” doe je met een array of List, liefst achter een nette blackbox

this verwijst naar het huidige object; favor composition over inheritance

Tip

Volgende halte: polymorfisme, waar één naam vele vormen aanneemt.

Meer weten

Kennisclips

Oefeningen H15 · 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 een PC met een harde schijf opbouwen via aggregatie en daarna de capaciteit tonen. Toch crasht het programma. Wat loopt er mis?

internal class HardeSchijf
{
    public int MaxCapacity { get; set; }
}

internal class PC
{
    public HardeSchijf CHardeSchijf { get; set; }

    public override string ToString()
    {
        return $"Capaciteit HD: {CHardeSchijf.MaxCapacity} Gb";
    }
}
PC mijnPC = new PC();
Console.WriteLine(mijnPC);

Opmerking

CHardeSchijf werd nooit een object toegewezen en is dus null. Bij CHardeSchijf.MaxCapacity krijg je daarom een NullReferenceException. Steek eerst een harde schijf in de PC (mijnPC.CHardeSchijf = new HardeSchijf();) of controleer op null in ToString voor je de property gebruikt.

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf