OOP — De constructor

Wat is een constructor?

In de vorige les maakten we objecten zo aan:

Hond mijnHond = new Hond();
mijnHond.Naam     = "Rex";
mijnHond.Ras      = "Labrador";
mijnHond.Leeftijd = 3;

Dat zijn vier aparte regels voor één object. Met tien honden worden dat veertig regels. Vervelend!

Een constructor is een speciale methode die automatisch uitgevoerd wordt op het moment dat je new schrijft. Je kan er meteen de beginwaarden in meegeven:

Hond mijnHond = new Hond("Rex", "Labrador", 3);  // alles in één regel!

Hoe werkt new precies?

sequenceDiagram
    participant Main
    participant Hond
    Main->>Hond: new Hond("Rex", "Labrador", 3)
    Note over Hond: Constructor wordt uitgevoerd
    Hond->>Hond: Naam = "Rex"
    Hond->>Hond: Ras = "Labrador"
    Hond->>Hond: Leeftijd = 3
    Hond-->>Main: object klaar ✓

Stap 1 — Constructor schrijven

Een constructor heeft drie kenmerken:

1. Dezelfde naam als de klasse (inclusief hoofdletter)
2. Geen return-type — niet eens void
3. Parameters voor de beginwaarden

public class Hond
{
    public string Naam     { get; set; }
    public string Ras      { get; set; }
    public int    Leeftijd { get; set; }

    // Constructor ↓
    public Hond(string naam, string ras, int leeftijd)
    {
        Naam     = naam;      // eigenschap = parameter
        Ras      = ras;
        Leeftijd = leeftijd;
    }
}

Naamconventie: parameters vs eigenschappen

Parameters beginnen met een kleine letter: naam, ras, leeftijd
Eigenschappen beginnen met een hoofdletter: Naam, Ras, Leeftijd
Zo weet je altijd het verschil!

Stap 2 — Constructor aanroepen

Je roept de constructor aan via new:

Hond hond1 = new Hond("Rex",  "Labrador", 3);
Hond hond2 = new Hond("Fifi", "Poedel",   7);
Hond hond3 = new Hond("Max",  "Beagle",   1);

Console.WriteLine(hond1.Naam);  // Rex
Console.WriteLine(hond2.Naam);  // Fifi
Console.WriteLine(hond3.Naam);  // Max

Elk object krijgt meteen de juiste waarden — veel korter dan zonder constructor!

Vergelijking: zonder en met constructor

flowchart TB
    subgraph Zonder["❌ Zonder constructor (4 regels per object)"]
        direction TB
        A1["Hond h = new Hond()"]
        A2["h.Naam = 'Rex'"]
        A3["h.Ras = 'Labrador'"]
        A4["h.Leeftijd = 3"]
        A1 --> A2 --> A3 --> A4
    end
    subgraph Met["✅ Met constructor (1 regel per object)"]
        direction TB
        B1["Hond h = new Hond('Rex', 'Labrador', 3)"]
    end

Meerdere constructors — overloading

Je kan ook meerdere constructors schrijven voor dezelfde klasse. Dit heet overloading. Ze moeten wel verschillende parameters hebben.

public class Hond
{
    public string Naam     { get; set; }
    public string Ras      { get; set; }
    public int    Leeftijd { get; set; }

    // Constructor 1: alles meegeven
    public Hond(string naam, string ras, int leeftijd)
    {
        Naam     = naam;
        Ras      = ras;
        Leeftijd = leeftijd;
    }

    // Constructor 2: alleen naam meegeven, rest krijgt standaardwaarden
    public Hond(string naam)
    {
        Naam     = naam;
        Ras      = "Onbekend";
        Leeftijd = 0;
    }
}

Gebruik:

Hond hond1 = new Hond("Rex", "Labrador", 3);  // Constructor 1
Hond hond2 = new Hond("Onbekende hond");       // Constructor 2

C# kiest automatisch de juiste constructor op basis van het aantal en type parameters.

Volledig voorbeeld

using System;

namespace H9c
{
    public class Fiets
    {
        public string Merk              { get; set; }
        public string Kleur             { get; set; }
        public int    AantalVersnellingen { get; set; }

        public Fiets(string merk, string kleur, int aantalVersnellingen)
        {
            Merk                = merk;
            Kleur               = kleur;
            AantalVersnellingen = aantalVersnellingen;
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            Fiets f1 = new Fiets("Trek",  "Rood",  21);
            Fiets f2 = new Fiets("Giant", "Zwart",  7);
            Fiets f3 = new Fiets("Cube",  "Blauw", 11);

            Console.WriteLine($"{f1.Merk} ({f1.Kleur}) — {f1.AantalVersnellingen} versnellingen");
            Console.WriteLine($"{f2.Merk} ({f2.Kleur}) — {f2.AantalVersnellingen} versnellingen");
            Console.WriteLine($"{f3.Merk} ({f3.Kleur}) — {f3.AantalVersnellingen} versnellingen");
        }
    }
}

Uitvoer:

Trek (Rood) — 21 versnellingen
Giant (Zwart) — 7 versnellingen
Cube (Blauw) — 11 versnellingen

Samenvatting

classDiagram
    class Fiets {
        +string Merk
        +string Kleur
        +int AantalVersnellingen
        +Fiets(merk, kleur, aantalVersnellingen)
    }
    note for Fiets "De constructor initialiseert\nalle eigenschappen in één keer"

Onthoud

• Een constructor heeft dezelfde naam als de klasse en geen return-type
• Je roept hem aan via new KlasseNaam(parameters)
• Parameters beginnen met een kleine letter, eigenschappen met een hoofdletter
• Je kan meerdere constructors schrijven met verschillende parameters (overloading)
• Een constructor maakt objecten aanmaken korter en leesbaarder

Veelgemaakte fout

public void Fiets(string merk) { }  // ❌ FOUT: void is niet toegestaan!
public Fiets(string merk)      { }  // ✅ GOED: geen return-type