OOP — Methoden in een klasse

Wat zijn instance-methoden?

Je kent al methoden uit Hoofdstuk 7: stukken code met een naam die je kan hergebruiken. Het verschil in OOP is dat methoden bij een object horen. Ze hebben toegang tot de eigenschappen van dat specifieke object.

Zo’n methode heet een instance-methode — ze is gekoppeld aan een concreet object (een instantie van de klasse).

sequenceDiagram
    participant Main
    participant h as hond (object)
    Main->>h: h.Roep()
    Note over h: gebruikt eigen eigenschap Naam
    h-->>Main: print "Woef! Ik ben Rex."

Stap 1 — Een methode schrijven in een klasse

Een methode schrijf je in de klasse, naast de properties en constructor:

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

    public Hond(string naam, string ras)
    {
        Naam = naam;
        Ras  = ras;
    }

    // Methode zonder return-waarde
    public void Roep()
    {
        Console.WriteLine($"Woef! Ik ben {Naam}.");
    }

    // Methode met return-waarde
    public string StelVoor()
    {
        return $"Ik ben {Naam}, een {Ras}.";
    }
}

Instance-methode vs static methode

In Hoofdstuk 7 schreef je public static void Methode() in de Program-klasse.
Een instance-methode in een klasse heeft geen static:
public void Roep() — hoort bij een specifiek object en heeft toegang tot zijn eigenschappen.

Stap 2 — Een methode aanroepen op een object

Je roept een methode aan via de punt-notatie op het object:

Hond h = new Hond("Rex", "Labrador");
h.Roep();                              // print: Woef! Ik ben Rex.

string info = h.StelVoor();
Console.WriteLine(info);               // print: Ik ben Rex, een Labrador.

Elk object heeft zijn eigen methodegedrag op basis van zijn eigen eigenschappen:

Hond h1 = new Hond("Rex",  "Labrador");
Hond h2 = new Hond("Fifi", "Poedel");

Console.WriteLine(h1.StelVoor());  // Ik ben Rex, een Labrador.
Console.WriteLine(h2.StelVoor());  // Ik ben Fifi, een Poedel.

flowchart LR
    subgraph h1["hond h1 (Rex)"]
        S1["StelVoor()"]
    end
    subgraph h2["hond h2 (Fifi)"]
        S2["StelVoor()"]
    end
    Main["Main"]
    Main -->|"h1.StelVoor()"| S1
    S1 -->|"Ik ben Rex, een Labrador."| Main
    Main -->|"h2.StelVoor()"| S2
    S2 -->|"Ik ben Fifi, een Poedel."| Main

Stap 3 — Methoden die de toestand wijzigen

Methoden kunnen ook eigenschappen van het object aanpassen. Dit is de kern van OOP: het object beheert zijn eigen toestand.

public class Teller
{
    public int Waarde { get; private set; }

    public Teller()
    {
        Waarde = 0;
    }

    public void VerhoogMetEen()
    {
        Waarde++;
    }

    public void Reset()
    {
        Waarde = 0;
    }
}

sequenceDiagram
    participant Main
    participant t as teller (object)
    Main->>t: new Teller() → Waarde = 0
    Main->>t: t.VerhoogMetEen()
    Note over t: Waarde = 1
    Main->>t: t.VerhoogMetEen()
    Note over t: Waarde = 2
    Main->>t: t.Reset()
    Note over t: Waarde = 0
    t-->>Main: t.Waarde = 0

Gebruik:

Teller t = new Teller();
Console.WriteLine(t.Waarde);  // 0
t.VerhoogMetEen();
t.VerhoogMetEen();
Console.WriteLine(t.Waarde);  // 2
t.Reset();
Console.WriteLine(t.Waarde);  // 0

Stap 4 — Methoden met parameters

Methoden kunnen ook parameters ontvangen, net als gewone methoden:

public class Auto
{
    public string Merk      { get; set; }
    public int    AantalKm  { get; private set; }

    public Auto(string merk)
    {
        Merk     = merk;
        AantalKm = 0;
    }

    public void Rij(int km)          // parameter: hoeveel km rijden
    {
        AantalKm += km;
    }

    public void ToonInfo()
    {
        Console.WriteLine($"{Merk}: {AantalKm} km");
    }
}

Gebruik:

Auto a = new Auto("Toyota");
a.Rij(100);
a.Rij(50);
a.ToonInfo();  // Toyota: 150 km

Overzicht: alle soorten methoden

flowchart TD
    M["Methode"] --> V["void\n(geeft niets terug)"]
    M --> R["return\n(geeft iets terug)"]
    V --> V1["void zonder params\npublic void Roep()"]
    V --> V2["void met params\npublic void Rij(int km)"]
    R --> R1["return zonder params\npublic string StelVoor()"]
    R --> R2["return met params\npublic int Kwadraat(int n)"]

Volledig voorbeeld

using System;

namespace H9c
{
    public class BankRekening
    {
        public string Naam  { get; set; }
        public int    Saldo { get; private set; }

        public BankRekening(string naam, int beginSaldo)
        {
            Naam  = naam;
            Saldo = beginSaldo;
        }

        public void Storten(int bedrag)
        {
            Saldo += bedrag;
        }

        public bool Afhalen(int bedrag)
        {
            if (bedrag <= Saldo)
            {
                Saldo -= bedrag;
                return true;
            }
            return false;
        }

        public void ToonSaldo()
        {
            Console.WriteLine($"{Naam}: €{Saldo}");
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            BankRekening r = new BankRekening("Emma", 100);
            r.ToonSaldo();       // Emma: €100

            r.Storten(50);
            r.ToonSaldo();       // Emma: €150

            bool gelukt = r.Afhalen(200);
            Console.WriteLine(gelukt ? "Gelukt" : "Onvoldoende saldo");  // Onvoldoende saldo
            r.ToonSaldo();       // Emma: €150
        }
    }
}

Uitvoer:

Emma: €100
Emma: €150
Onvoldoende saldo
Emma: €150

Alles samen: de structuur van een klasse

classDiagram
    class BankRekening {
        +string Naam
        +int Saldo
        +BankRekening(naam, beginSaldo)
        +Storten(bedrag)
        +Afhalen(bedrag) bool
        +ToonSaldo()
    }
    note for BankRekening "Eigenschappen slaan data op\nConstructor initialiseert het object\nMethoden bepalen het gedrag"

Een klasse bestaat altijd uit drie lagen:

1. Eigenschappen — de data van het object (Naam, Saldo)
2. Constructor — initialiseert het object bij aanmaken
3. Methoden — het gedrag van het object (Storten, Afhalen, ToonSaldo)

Samenvatting

Onthoud

• Instance-methoden horen bij een object en hebben toegang tot zijn eigenschappen
• Ze hebben geen static — dat is het verschil met methoden uit Hoofdstuk 7
• Je roept ze aan met punt-notatie: object.Methode()
• Elk object voert methoden uit op basis van zijn eigen eigenschappen
• Methoden kunnen de toestand van het object lezen én wijzigen
• Een methode zonder return-waarde heeft als type void

Veelgemaakte fout: static vergeten verwijderen

public static void Roep()   // ❌ FOUT: static = niet gekoppeld aan object
{
    Console.WriteLine(Naam); // fout: Naam bestaat niet in static context
}

public void Roep()          // ✅ GOED: instance-methode
{
    Console.WriteLine(Naam); // correct: toegang tot eigenschap van dit object
}