Wat leer je in dit hoofdstuk?

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

Waar staan we?

Een klasse bestond tot nu uit:

instantievariabelen

de toestand

methoden

het gedrag

properties

gecontroleerde toegang

Daar komen nu bij:

constructors

static

object initializer syntax

Constructors

De new operator

Student frankVermeulen = new Student();

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.

Soorten constructors

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.

Een default constructor

internal class Student
{
    public Student()
    {
        UurVanInschrijven = DateTime.Now.Hour;
    }

    public int UurVanInschrijven {private set; get;}
}

altijd public

geen returntype, ook geen void

naam = klassenaam

( ) geen parameters

Een default constructor: het effect

Student eenStudent = new Student();

Voer je dit om half twaalf ’s morgens uit, dan staat UurVanInschrijven op 11.

Tip

Enkel een auto-property een startwaarde geven? Dan heb je geen constructor nodig:

public int UurVanInschrijven {private set; get;} = 2;

Overloaded constructors

internal class Student
{
    public Student(string bijnaamIn)
    {
        BijNaam = bijnaamIn;
    }
    public string BijNaam { get; private set;}
}

Zo kan je new Student("Lord Oakenwood") schrijven.

De default constructor is weg

new Student() werkt niet meer:

There is no argument given that corresponds to the required parameter ‘bijnaamIn’ of ‘Student.Student(string)’

Met meerdere constructors wordt dat “‘Student’ does not contain a constructor that takes 0 arguments”. Wil je hem terug, schrijf hem dan zelf:

private const string DEFBIJNAAM = "Geen";
//Default
public Student()
{
    BijNaam = DEFBIJNAAM;
}

Meerdere overloaded constructors

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.

Laat de property controleren

private const string DEFBIJNAAM = "Good boy";

public Student(string bijnaamIn)
{
    BijNaam = bijnaamIn;
}

public string BijNaam
{
    private set
    {
        if(value == "stommerik")
            bijNaam = DEFBIJNAAM;
        else
            bijNaam = value;
    }
    get { return bijNaam; }
}
private string bijNaam;

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.

Dubbele code in constructors

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.

this(): constructors hergebruiken

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.

this(): constructors hergebruiken

Alle constructors laten hun werk over aan één hoofdconstructor.

In welke volgorde?

public Microfoon(bool isUitverkochtIn): this("Bovarc", isUitverkochtIn)
{
    Merk = "Wit Product";
}

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

Welke constructors voorzien?

Minstens genoeg om alle essentiële variabelen een beginwaarde te geven.

internal class Breuk
{
    public int Noemer {get; private set;}
    public int Teller {get; private set;}
    public double BerekenBreuk()
    {
        return (double)Teller/Noemer;
    }
}
Breuk eenBreuk = new Breuk();
double resultaat = eenBreuk.BerekenBreuk(); //NaN: geen crash, wel onzin

Een Breuk die klopt

internal class Breuk
{
    public Breuk(int tellerIn, int noemerIn)
    {
        Teller = tellerIn;
        Noemer = noemerIn;
    }
    public int Teller {get; private set;}

    private int noemer;
    public int Noemer
    {
        get { return noemer; }
        private set
        {
            if(value != 0)
                noemer = value;
            else
                noemer = 1;
        }
    }
}

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.

Pong met constructors

internal class Balletje
{
    public Balletje(int xin, int yin, int vxIn, int vyIn)
    {
        X = xin;
        Y = yin;
        VX = vxIn;
        VY = vyIn;
    }

    public Balletje(): this(5,5,1,1)
    {
    }
    //...
Balletje bal1 = new Balletje();
Balletje bal2 = new Balletje(10,8,-2,1);

Een willekeurig balletje

De default constructor mag het balletje ook een willekeurige plek en snelheid geven:

static Random rng = new Random();

public Balletje()
{
    X = rng.Next(0, Console.WindowWidth);
    Y = rng.Next(0, Console.WindowHeight);
    VX = rng.Next(-2,3);
    VY = rng.Next(-2,3);
}

Object initializer syntax

Object initializer syntax

Geef properties een beginwaarde bij de creatie, zonder een aparte constructor:

internal class Meting
{
    public double Temperatuur {get;set;}
    public bool IsGeconfirmeerd {get;set;}
}
Meting meting = new Meting() { Temperatuur = 3.4, IsGeconfirmeerd = true};
Meting meting = new Meting { Temperatuur = 3.4, IsGeconfirmeerd = true};

De ronde haakjes van de default constructor mag je weglaten. Je hoeft ook niet alle properties in te stellen.

Wat gebeurt er intern?

Eerst de default constructor, pas daarna de properties:

Meting meting = new Meting();
meting.Temperatuur = 3.4;
meting.IsGeconfirmeerd = true;

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.

required properties

De default constructor verplicht niets. Wil je toch dat een property ingesteld wordt? Gebruik required:

internal class Meting
{
    public double Temperatuur {get;set;}
    public required bool IsGeconfirmeerd {get;set;}
}
Meting meting = new Meting { Temperatuur = 0.7};
Required member ‘Meting.IsGeconfirmeerd’ must be set in the object initializer or attribute constructor.

Belangrijk

required bestaat sinds C# 11 en werkt enkel in .NET 7 of nieuwer.

Static

static: het idee

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

Zonder static fields

internal class Mens
{
    private int geboorteJaar;
    public int Geboortejaar
    {
        get { return geboorteJaar; }
        private set { geboorteJaar = value; }
    }
    public void Jarig()
    {
        Geboortejaar++;
    }
}
Mens m1 = new Mens();
Mens m2 = new Mens();
m1.Jarig();
m1.Jarig();
m2.Jarig();
Console.WriteLine($"{m1.Geboortejaar}");
Console.WriteLine($"{m2.Geboortejaar}");
2
1

Ieder object houdt zijn eigen instantievariabelen bij.

Mét static fields

internal class Mens
{
    private static int geboorteJaar = 1;
    public int Geboortejaar
    {
        get { return geboorteJaar; }
        private set { geboorteJaar = value; }
    }
    public void Jarig()
    {
        Geboortejaar++;
    }
}

Dezelfde code in Main geeft nu:

4
4

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.

Stagiair Steven

Steven wil het geboortejaar van één specifieke Mens tonen. De A.I. maakte de methode static “voor de snelheid”:

internal class Mens
{
    private int geboorteJaar = 1970;

    public static void ToonGeboortejaar()
    {
        Console.WriteLine(geboorteJaar);
    }
}

“static is toch sneller?”, denkt hij. Waarom compileert dit niet?

Stagiair Steven: wat liep er mis?

An object reference is required for the non-static field, method, or property

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.

Static methoden en klassen

Waarom kan je Math.Pow(3,2); schrijven zonder een object te maken?

Math myMath = new Math(); //dit mag niet!

De methoden van Math zijn static, en de klasse zelf ook:

internal static class Math
{
    public static double Pow(int getal, int macht)
    {
        //enz.

Belangrijk

Een static class mag enkel static members bevatten. Je kan er toch nooit een object van maken.

Je eigen bibliotheek

internal static class EpicLibrary
{
    static public void ToonInfo()
    {
        Console.WriteLine("Ik ben ik");
    }

    static public int TelOp(int a, int b)
    {
        return a+b;
    }
}
EpicLibrary.ToonInfo();
int opgeteld = EpicLibrary.TelOp(3,5);

Hybride klassen

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.

bool gaIkOpPensioenInEenSchrikkeljaar = DateTime.IsLeapYear(2048);

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

Intermezzo: Debug.WriteLine

using System.Diagnostics;

namespace debugdemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World! Console");
            Debug.WriteLine("Hello World! Debug");
        }
    }
}

In de console verschijnt enkel Hello World! Console. De tweede lijn staat in het Output-venster van VS.

Debug-uitvoer in het Output-venster.

Tip

Zo vergeet je geen Console.WriteLine met debug-informatie in je eindproduct.

Fietsen tellen

internal class Fiets
{
    private static int aantalFietsen = 0;
    public Fiets()
    {
        aantalFietsen++;
        Debug.WriteLine($"Er zijn nu {aantalFietsen} gemaakt");
    }
    public static void VerminderFiets()
    {
        aantalFietsen--;
        Debug.WriteLine($"STATIC: Er zijn {aantalFietsen} fietsen");
    }
}
Fiets merckx = new Fiets();
Fiets steels = new Fiets();
Fiets evenepoel = new Fiets();
Fiets.VerminderFiets();
Fiets aerts = new Fiets();
Fiets.VerminderFiets();
Er zijn nu 1 gemaakt
Er zijn nu 2 gemaakt
Er zijn nu 3 gemaakt
STATIC: Er zijn 2 fietsen
Er zijn nu 3 gemaakt
STATIC: Er zijn 2 fietsen

Hier is static wél logisch: iets bijhouden over alle objecten heen.

static versus non-static

Een static methode kan enkel andere static leden aanspreken. Van welk object zou ze anders gewicht nemen?

internal class Mens
{
    private int gewicht = 50;

    private static void VerminderGewicht()
    {
        gewicht--; // FOUT
    }
}

Wat mag wel, wat niet.

Tip

Daarom moet in Program.cs alles static zijn: static void Main(string[] args) is zelf static.

Static properties

Alle balletjes delen dezelfde grenzen van het speelveld:

static public int Breedte { get; set; }
static public int Hoogte { get; set; }
Balletje.Hoogte = Console.WindowHeight;
Balletje.Breedte = Console.WindowWidth;
// of zelf gekozen:
Balletje.Hoogte = 20;
Balletje.Breedte = 10;

Balletjes in een klein speelveld

public void Update()
{
    if (X + VX >= Balletje.Breedte || X + VX < 0)
    {
        VX = -VX;
    }
    X = X + VX;

    if (Y + VY >= Balletje.Hoogte || Y + VY < 0)
    {
        VY = -VY;
    }
    Y = Y + VY;
}
Balletje.Hoogte = 15;
Balletje.Breedte = 15;

Balletje m1 = new Balletje(1,1,1,1);
Balletje m2 = new Balletje(2,2,-2,1);

while (true)
{
    m1.Update();
    m1.TekenOpScherm();
    m2.Update();
    m2.TekenOpScherm();
    System.Threading.Thread.Sleep(50);
    Console.Clear();
}

static en Random

internal class Dobbelsteen
{
    public int Werp()
    {
        Random gen = new Random(42);  //SLECHT IDEE
        return gen.Next(1,7);
    }
}

Elke worp maakt een nieuwe generator met dezelfde seed en vraagt het eerste getal. Rol je 10 keer, dan krijg je 10 keer hetzelfde getal.

Eén gedeelde generator

internal class Dobbelsteen
{
    static Random gen = new Random();
    public int Werp()
    {
        return gen.Next(1,7);
    }
}

Tip

Er bestaat nu maar één generator, die alle dobbelstenen delen: de afspraak uit hoofdstuk 4, één generator voor je hele programma.

Conclusie

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

Meer weten

Kennisclips

Oefeningen H11 · Quizlet flashcards

Zie verder

Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.

Zie verder: zoek de fout

Onderstaande Java-klasse wil bijhouden hoeveel fietsen er gemaakt zijn, maar de teller blijft hangen op 1. Wat loopt er mis?

class Fiets {
    int aantalFietsen = 0;
    Fiets() {
        aantalFietsen++;
    }
}

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

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf