1. Uitleg Inheritance en Abstract Classes

Wat is inheritance?

Inheritance (overerving) in C# is een mechanisme waarmee een klasse (child/subclass) eigenschappen en methoden kan overnemen van een andere klasse (parent/superclass). Dit bevordert codehergebruik en zorgt voor een hiërarchische structuur binnen een applicatie.

Wanneer is inheritance nuttig?

1. Codehergebruik: Je hoeft dezelfde methoden en eigenschappen niet opnieuw te schrijven in elke klasse.
2. Structuur en organisatie: Klassen met gedeelde functionaliteit kunnen worden gegroepeerd in een logische hiërarchie.
3. Polymorfisme ondersteunen: Subklassen kunnen methoden van de parentklasse overriden (override), waardoor dynamisch gedrag mogelijk wordt.
4. Onderhoud en uitbreidbaarheid: Wijzigingen in de parentklasse worden automatisch doorgevoerd in alle subklassen, wat het onderhoud vergemakkelijkt.

Casus

Een organisatie heeft werknemers. Er zijn managers en programmeurs. Om te voorkomen dat voor de klassen Manager en Programmeur allebei de property Naam moet worden geïmplementeerd wordt gekozen voor een parentklasse Werknemer.

Hoe gebruik je inheritance?

Voor inheritance implementatie worden klassen, abstracte klassen en abstracte methoden gebruikt.

Inheritance wordt geïmplementeerd met de : (dubbele punt) notatie: Programmeur : Werknemer. Dit betekent dat klasse Werknemer van klasse Programmeur erft. Het virtual keyword in het codevoorbeeld betekent dat een childklasse de methode mag overriden (overschrijven).

Codevoorbeeld inheritance

using System;
 
class Werknemer
{
    public string Naam { get; set; }
    public double Salaris { get; set; }
 
    public virtual void ToonInfo()
    {
        Console.WriteLine($"Naam: {Naam}, Salaris: {Salaris}");
    }
}
 
// Programmeur erft van Werknemer
class Programmeur : Werknemer
{
    public string Programmeertaal { get; set; }
 
    public override void ToonInfo()
    {
        Console.WriteLine($"Programmeur: {Naam}, Salaris: {Salaris}, Taal: {Programmeertaal}");
    }
}
 
// Manager erft van Werknemer
class Manager : Werknemer
{
    public int TeamLeden { get; set; }
 
    public override void ToonInfo()
    {
        Console.WriteLine($"Manager: {Naam}, Salaris: {Salaris}, Teamleden: {TeamLeden}");
    }
}
 
class Program
{
    static void Main()
    {
        Programmeur dev = new Programmeur { Naam = "Alice", Salaris = 5000, Programmeertaal = "C#" };
        Manager mgr = new Manager { Naam = "Bob", Salaris = 7000, TeamLeden = 5 };
 
        dev.ToonInfo();
        mgr.ToonInfo();
    }
}

Abstracte klassen

In het voorbeeld van zojuist kon een instantie van een Werknemer worden gemaakt: new Werknemer(). Dit is natuurlijk niet de bedoeling, want een werknemer is altijd van het type Manager of Programmeur. Om te voorkomen dat dit kan gebeuren, kan de klasse Werknemer abstract worden gemaakt: abstract class Werknemer. Dus: Een abstracte klasse kan zelf niet geïmplementeerd worden. Alleen de child klassen kunnen dit.

Abstracte methoden

Een abstracte methode is een methode zonder implementatie in de abstracte klasse. Klassen die erven van de abstracte klasse moeten deze methode verplicht implementeren.

Codevoorbeeld abstracte methoden

In onderstaande voorbeeld is de methode BerekenBonus abstract, dus de child klassen moeten deze methode implementeren.

using System;
 
abstract class Werknemer  // Abstracte klasse
{
    public string Naam { get; set; }
    public double Salaris { get; set; }
 
    public abstract double BerekenBonus(); // Abstracte methode
 
    public virtual void ToonInfo()
    {
        Console.WriteLine($"Naam: {Naam}, Salaris: {Salaris}, Bonus: {BerekenBonus()}");
    }
}

Vervolgens is voor de klassen Manager en Programmeur de methode geïmplementeerd.

 
// Programmeur erft van Werknemer en implementeert BerekenBonus()
class Programmeur : Werknemer
{
    public string Programmeertaal { get; set; }
 
    public override double BerekenBonus()
    {
        return Salaris * 0.10;  // 10% bonus
    }
 
    public override void ToonInfo()
    {
        Console.WriteLine($"Programmeur: {Naam}, Salaris: {Salaris}, Taal: {Programmeertaal}, Bonus: {BerekenBonus()}");
    }
}
 
// Manager erft van Werknemer en implementeert BerekenBonus()
class Manager : Werknemer
{
    public int TeamLeden { get; set; }
 
    public override double BerekenBonus()
    {
        return Salaris * 0.15 + (TeamLeden * 50);  // 15% bonus + €50 per teamlid
    }
 
    public override void ToonInfo()
    {
        Console.WriteLine($"Manager: {Naam}, Salaris: {Salaris}, Teamleden: {TeamLeden}, Bonus: {BerekenBonus()}");
    }
}
 
class Program
{
    static void Main()
    {
        Programmeur dev = new Programmeur { Naam = "Alice", Salaris = 5000, Programmeertaal = "C#" };
        Manager mgr = new Manager { Naam = "Bob", Salaris = 7000, TeamLeden = 5 };
 
        dev.ToonInfo();
        mgr.ToonInfo();
    }
}

---

Volgende stap: Oefeningen inheritance en abstracte klasse