Zie Scherp Scherper - Hoofdstuk 15
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.
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
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: een lijn met een volle ruit aan de kant van de klasse die de objecten in zich heeft.
Aggregatie: dezelfde lijn, met een lege ruit. Optioneel staan er getallen aan de uiteinden.
Tip
Ter herinnering: overerving is een pijl naar de parent-klasse.
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.
Een reeks huizen, met in elke slaapkamer een computer:
Een PC heeft een HardeSchijf, dus zit er in PC een instantievariabele van het type HardeSchijf:
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.
Meteen bij de instantievariabele, of via de constructor:
Sterft de PC, dan sterft de interne schijf mee: dat is compositie.
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.
Maak het object buiten de PC aan en steek het erin via een property:
Er blijft een externe referentie (mijnHardeSchijf), dus de GC ruimt de schijf niet op met de PC: dat is aggregatie.
Heeft HardeSchijf een auto-property MaxCapacity, dan kan PC die gewoon gebruiken:
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.
Een intern object aanspreken dat nooit werd aangemaakt: een klassieke fout. Controleer op null telkens je het gebruikt:
Opmerking
Alles in try-catch steken is op detailniveau niet werkbaar. Schrijf je code van bij de start met null-controles.
Een boek heeft veel pagina’s, dus een array:
Ook de individuele elementen moet je nog instantiëren.
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.
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.
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:
Werkt deze regel, ondanks de private set?
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.
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.
Een patiënt krijgt via een property (manier 3) een nieuw hart:
Belangrijk
patient.Hart = donor.Hart; kopieert niet: beide verwijzen naar hetzelfde Hart-object. Een object delen is niet hetzelfde als een object kopiëren.
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”.
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”.
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.
Levens = 5; past de parameter aan (niet aangeraden). Met this geraak je aan de property met dezelfde naam.
Tip
Levens als naam voor de parameter is sowieso een ongelukkige keuze.
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.
Kennisclips
Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.
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?
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.
Alles uit dit hoofdstuk op één A4.