Zie Scherp Scherper - Hoofdstuk 11
Na dit hoofdstuk kan je:
een constructor schrijven om de beginstaat van een object in te stellen
het verschil tussen een default en een overloaded constructor uitleggen
constructors hergebruiken met this()
objecten opzetten met object initializer syntax en required
het keyword static gebruiken voor fields, methoden, properties en klassen
uitleggen waarom een static deel niet bij de niet-static delen kan
Een klasse bestond tot nu uit:
instantievariabelen
de toestand
methoden
het gedrag
properties
gecontroleerde toegang
Daar komen nu bij:
constructors
static
object initializer syntax
new doet drie dingen:
1. een object aanmaken in de heap
2. de constructor aanroepen voor extra initialisatie
3. een referentie naar dat object teruggeven
Vandaar de ronde haakjes bij new Student(): dat is de constructor-aanroep.
Belangrijk
Een constructor wordt maar op één moment aangeroepen: bij de geboorte van het object, met new. Op geen enkel ander moment.
Geen zelfgeschreven constructor
een onzichtbare default constructor wordt voor je uitgevoerd
Enkel een default constructor (zonder parameters)
maar zelf ingevuld
Een of meer overloaded constructors
met parameters, bv. new Student(24, "Jos")
Waarschuwing
Net als met aannemers: soms ruimen ze zelf op, soms niet. Schrijf je zelf een constructor, dan ben je de gratis default constructor kwijt.
altijd public
geen returntype, ook geen void
naam = klassenaam
( ) geen parameters
Voer je dit om half twaalf ’s morgens uit, dan staat UurVanInschrijven op 11.
Zo kan je new Student("Lord Oakenwood") schrijven.
new Student() werkt niet meer:
Met meerdere constructors wordt dat “‘Student’ does not contain a constructor that takes 0 arguments”. Wil je hem terug, schrijf hem dan zelf:
internal class Student
{
private const string DEFBIJNAAM = "Geen";
//Default
public Student()
{
BijNaam = DEFBIJNAAM;
}
//Overloaded 1
public Student(string bijnaamIn)
{
BijNaam = bijnaamIn;
}
//Overloaded 2
public Student(string bijnaamIn, bool isWerkStudentIn)
{
BijNaam = bijnaamIn;
IsWerkStudent = isWerkStudentIn;
}
public string BijNaam { get; private set;}
public bool IsWerkStudent { get; private set;}
}Geen constructors: je krijgt er een gratis.
Eén zelf geschreven: je krijgt niets meer gratis.
Roep in je constructor de property aan, niet de instantievariabele. Dan doet de set meteen zijn controle.
Tip
Leg de verantwoordelijkheid bij het element zelf. Zo hoeft niet elke constructor de parameters te controleren.
internal class Microfoon
{
public Microfoon(string merkIn, bool isUitverkochtIn)
{
IsUitverkocht = isUitverkochtIn;
Merk = merkIn;
}
public Microfoon(string merkIn)
{
IsUitverkocht = false;
Merk = merkIn;
}
public Microfoon()
{
Merk = "Onbekend";
IsUitverkocht = true;
}
public string Merk { get; set;}
public bool IsUitverkocht {get; set;}
}Drie constructors die bijna hetzelfde doen.
Waarschuwing
Hoor je een alarmbelletje? Terecht: telkens dezelfde toewijzingen.
internal class Microfoon
{
public Microfoon(string merkIn, bool isUitverkochtIn)
{
IsUitverkocht = isUitverkochtIn;
Merk = merkIn;
}
public Microfoon(string merkIn): this(merkIn, false)
{ }
public Microfoon(): this ("Onbekend", true)
{ }
public string Merk { get; set;}
public bool IsUitverkocht {get; set;}
}De compiler kiest via method overload resolution de best passende constructor, op basis van het aantal en het type parameters.
Alle constructors laten hun werk over aan één hoofdconstructor.
Wat is het merk na new Microfoon(true)?
1. Microfoon(bool) wordt aangeroepen
2. eerst loopt this("Bovarc", true): Merk wordt Bovarc
3. dan de eigen code: Merk wordt Wit Product
Minstens genoeg om alle essentiële variabelen een beginwaarde te geven.
Er is enkel nog een constructor met een teller en een noemer. new Breuk() compileert niet meer, new Breuk(21,8) wel.
Tip
Zo dwing je de gebruiker van je klasse om ze correct te gebruiken. Een noemer 0 wordt in de set een 1.
De default constructor mag het balletje ook een willekeurige plek en snelheid geven:
Geef properties een beginwaarde bij de creatie, zonder een aparte constructor:
De ronde haakjes van de default constructor mag je weglaten. Je hoeft ook niet alle properties in te stellen.
Eerst de default constructor, pas daarna de properties:
Waarschuwing
Werkt enkel voor properties met een set die van buitenaf bereikbaar is. Een private set kan je er niet mee instellen.
Tip
Het kan ook na een overloaded constructor: dan komen de accolades achter de ronde haakjes met de actuele parameters.
De default constructor verplicht niets. Wil je toch dat een property ingesteld wordt? Gebruik required:
Belangrijk
required bestaat sinds C# 11 en werkt enkel in .NET 7 of nieuwer.
static geeft aan dat een element bij de klasse zelf hoort, niet bij een individueel object.
Je kan het dus aanroepen zonder een object te maken. Het kan op vier plaatsen:
static field
een variabele gedeeld over alle objecten
static method
hulpmethoden, zoals Math.Pow()
static class
geen objecten van te maken, zoals Console
static property
zoals DateTime.Now
Ieder object houdt zijn eigen instantievariabelen bij.
Dezelfde code in Main geeft nu:
Alle objecten delen geboorteJaar: er bestaat er maar één van in het geheugen.
Waarschuwing
Dit voorbeeld is bewust artificieel: een geboortejaar hoort net per persoon. Het toont enkel de mechaniek. Gebruik static met mate, het druist vaak in tegen OOP.
Steven wil het geboortejaar van één specifieke Mens tonen. De A.I. maakte de methode static “voor de snelheid”:
“static is toch sneller?”, denkt hij. Waarom compileert dit niet?
Opmerking
Een static methode hoort bij de klasse, niet bij een object. Van welk object zou ze geboorteJaar moeten tonen? Wil Steven het geboortejaar van één Mens, dan mag de methode net niet static zijn: adil.ToonGeboortejaar(). En “sneller” is geen reden: het gaat erover of iets bij de klasse of bij het object hoort.
Waarom kan je Math.Pow(3,2); schrijven zonder een object te maken?
Een klasse mag ook deels static zijn. DateTime is daar een voorbeeld van: de meeste zaken zijn niet static, maar Now en IsLeapYear roep je op de klasse aan.
Waarschuwing
Voor een methode of klasse kan er nu al heel wat staan: een access modifier (internal, private), al dan niet static, en bij methoden een returntype (void, int, …).
In de console verschijnt enkel Hello World! Console. De tweede lijn staat in het Output-venster van VS.
Tip
Zo vergeet je geen Console.WriteLine met debug-informatie in je eindproduct.
Hier is static wél logisch: iets bijhouden over alle objecten heen.
Een static methode kan enkel andere static leden aanspreken. Van welk object zou ze anders gewicht nemen?
Tip
Daarom moet in Program.cs alles static zijn: static void Main(string[] args) is zelf static.
Alle balletjes delen dezelfde grenzen van het speelveld:
Tip
Er bestaat nu maar één generator, die alle dobbelstenen delen: de afspraak uit hoofdstuk 4, één generator voor je hele programma.
new maakt een object in de heap, roept de constructor aan en geeft een referentie terug
Schrijf je zelf een constructor, dan ben je de gratis default constructor kwijt
this(...) hergebruikt constructors; object initializer syntax en required vullen properties in
static hoort bij de klasse, niet bij een object: gedeelde data en hulpmethoden
Een static deel kan enkel andere static delen aanspreken
Tip
Volgende halte: arrays en collecties van objecten (List, foreach, Dictionary).
Kennisclips
Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.
Onderstaande Java-klasse wil bijhouden hoeveel fietsen er gemaakt zijn, maar de teller blijft hangen op 1. Wat loopt er mis?
Opmerking
aantalFietsen is hier een gewone instantievariabele, dus elk Fiets-object krijgt z’n eigen kopie die in de constructor van 0 naar 1 gaat. Je wilt één teller die gedeeld wordt over alle objecten, dus moet de variabele static zijn: static int aantalFietsen = 0;. Dezelfde redenering geldt in C#.
Alles uit dit hoofdstuk op één A4.