C# Inheritance Uitgelegd

Deze gids dekt de fundamenten van inheritance in C#, de verschillende vormen en praktische codevoorbeelden.

Inheritance in C# laat u een nieuwe klasse aanmaken die afstamt van een bestaande, wat een parent (base) en child (derived) relatie vormt. Deze krachtige feature van Object-Georiënteerd Programmeren (OOP) bevordert codeherbruik en logische organisatie.

De base klasse levert velden, properties en methodes die de derived klasse erft, wat de child toestaat gedrag uit te breiden of aan te passen terwijl gedeelde logica op één plek blijft.

Hoe Inheritance te Declareren in C#

In C# duidt de dubbele punt (:) inheritance aan:

class Animal {
    // velden en methodes
}
// Dog erft van Animal
class Dog : Animal {
    // velden en methodes van Animal
    // velden en methodes van Dog
}

Hier breidt Dog Animal uit, wat toegang geeft tot de leden. Het diagram hieronder illustreert de relatie.

Voorbeeld: Basis Inheritance

using System;
namespace Inheritance {
    // Base klasse
    class Animal {
        public string name;
        public void Display() {
            Console.WriteLine("Ik ben een dier");
        }
    }
    // Derived klasse
    class Dog : Animal {
        public void GetName() {
            Console.WriteLine("Mijn naam is " + name);
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog labrador = new Dog();
            labrador.name = "Rohu";
            labrador.Display();
            labrador.GetName();
            Console.ReadLine();
        }
    }
}

Output

Ik ben een dier
Mijn naam is Rohu

In dit voorbeeld erft Dog het name veld en Display() methode van Animal. De derived klasse kan ook eigen leden toevoegen, zoals GetName().

De "is-een" Relatie

Inheritance vertegenwoordigt een "is-een" relatie. Gebruik het wanneer een klasse logisch een gespecialiseerde vorm is van een andere.

• Dog is een Animal
• Appel is een Fruit
• Auto is een Voertuig

Deze relaties rechtvaardigen het afleiden van Dog van Animal, Appel van Fruit en Auto van Voertuig.

Protected Leden in Inheritance

Wanneer een veld of methode gedeclareerd is als protected, is het toegankelijk binnen de eigen klasse en alle derived klassen, maar verborgen voor externe code.

Voorbeeld: Protected Methodes Gebruiken

using System;
namespace Inheritance {
    class Animal {
        protected void Eat() {
            Console.WriteLine("Ik kan eten");
        }
    }
    class Dog : Animal {
        static void Main(string[] args) {
            Dog labrador = new Dog();
            labrador.Eat();
            Console.ReadLine();
        }
    }
}

Output

Ik kan eten

Omdat Eat() protected is, kan de Dog klasse het aanroepen, maar code buiten de hiërarchie kan niet.

Types van Inheritance

Inheritance manifesteert zich in verschillende patronen:

1. Single Inheritance

Een enkele derived klasse erft van één base klasse.

2. Multilevel Inheritance

Een keten van inheritance waar een klasse erft van een base, dan een andere klasse erft van die derived klasse.

3. Hierarchical Inheritance

Meerdere derived klassen delen dezelfde base klasse.

4. Multiple Inheritance

Terwijl C# geen inheriting van meerdere klassen ondersteunt, bieden interfaces een flexibele alternatief voor vergelijkbaar gedrag.

5. Hybrid Inheritance

Een combinatie van twee of meer inheritance types, zoals multilevel plus hierarchical.

Methode Overriding

Wanneer een derived klasse een methode declareert met dezelfde handtekening als een base klasse methode gemarkeerd virtual, kan de derived methode het overschrijven met override. Dit stelt polymorf gedrag in.

using System;
namespace Inheritance {
    class Animal {
        public virtual void Eat() {
            Console.WriteLine("Ik eet voedsel");
        }
    }
    class Dog : Animal {
        public override void Eat() {
            Console.WriteLine("Ik eet hondenvoer");
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog labrador = new Dog();
            labrador.Eat();
        }
    }
}

Output

Ik eet hondenvoer

De Eat() methode in Dog overschrijft die in Animal. Het virtual keyword toestaat de override, terwijl override de substitutie signaleert.

De base Keyword Gebruiken

Soms moet u de base klasse implementatie aanroepen vanuit een overriding methode. Het base keyword faciliteert dit.

Voorbeeld: Base Methodes Aanroepen

using System;
namespace Inheritance {
    class Animal {
        public virtual void Eat() {
            Console.WriteLine("Dieren eten voedsel.");
        }
    }
    class Dog : Animal {
        public override void Eat() {
            base.Eat();
            Console.WriteLine("Honden eten hondenvoer.");
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog labrador = new Dog();
            labrador.Eat();
        }
    }
}

Output

Dieren eten voedsel.
Honden eten hondenvoer.

Hier roept base.Eat() de Animal implementatie aan voordat de derived klasse logica uitgevoerd wordt.

Waarom Inheritance Belangrijk Is in C#

Inheritance stelt herbruikbare logica in over gerelateerde klassen. Overweeg geometrische vorm waar omtrekberekeningen een gemeenschappelijke formule delen.

1. Maak een RegularPolygon base klasse met een CalculatePerimeter() methode.
2. Leid Square en Rectangle af, voeg specifieke properties toe zoals Length en Sides.
3. Elke derived klasse kan ook een eigen area berekening implementeren terwijl de perimeter logica herbruikt wordt.

Illustratief Voorbeeld

using System;
namespace Inheritance {
    class RegularPolygon {
        public void CalculatePerimeter(int length, int sides) {
            int result = length * sides;
            Console.WriteLine("Omtrek: " + result);
        }
    }
    class Square : RegularPolygon {
        public int Length = 200;
        public int Sides = 4;
        public void CalculateArea() {
            int area = Length * Length;
            Console.WriteLine("Oppervlakte van Vierkant: " + area);
        }
    }
    class Rectangle : RegularPolygon {
        public int Length = 100;
        public int Breadth = 200;
        public int Sides = 4;
        public void CalculateArea() {
            int area = Length * Breadth;
            Console.WriteLine("Oppervlakte van Rechthoek: " + area);
        }
    }
    class Program {
        static void Main(string[] args) {
            Square s1 = new Square();
            s1.CalculateArea();
            s1.CalculatePerimeter(s1.Length, s1.Sides);
            Rectangle t1 = new Rectangle();
            t1.CalculateArea();
            t1.CalculatePerimeter(t1.Length, t1.Sides);
        }
    }
}

Output

Oppervlakte van Vierkant: 40000
Omtrek: 800
Oppervlakte van Rechthoek: 20000
Omtrek: 400

Dit patroon toont hoe inheritance duplicatie vermindert en onderhoudbaarheid verbetert.