C# Vererbung meistern: Konzepte, Typen und praktischer Code

C# Vererbung erklärt

Dieser Leitfaden deckt die Grundlagen der Vererbung in C#, ihre verschiedenen Formen und praktische Codebeispiele ab.

Vererbung in C# ermöglicht das Erstellen einer neuen Klasse, die von einer bestehenden ableitet, wodurch eine Eltern- (Basis-) und Kind- (abgeleitete) Beziehung entsteht. Dieses mächtige Feature der objektorientierten Programmierung (OOP) fördert Codewiederverwendung und logische Organisation.

Die Basisklasse liefert Felder, Eigenschaften und Methoden, die die abgeleitete Klasse erbt, sodass das Kind Verhalten erweitern oder anpassen kann, während gemeinsame Logik an einem Ort bleibt.

---

Vererbung in C# deklarieren

In C# kennzeichnet der Doppelpunkt (:) Vererbung:

class Animal {
    // Felder und Methoden
}
// Dog erbt von Animal
class Dog : Animal {
    // Felder und Methoden von Animal
    // Felder und Methoden von Dog
}

Hier erweitert Dog Animal und erhält Zugriff auf dessen Member. Das Diagramm unten illustriert die Beziehung.

---

Beispiel: Grundlegende Vererbung

using System;
namespace Inheritance {
    // Basisklasse
    class Animal {
        public string name;
        public void Display() {
            Console.WriteLine("I am an animal");
        }
    }
    // Abgeleitete Klasse
    class Dog : Animal {
        public void GetName() {
            Console.WriteLine("My name is " + name);
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog labrador = new Dog();
            labrador.name = "Rohu";
            labrador.Display();
            labrador.GetName();
            Console.ReadLine();
        }
    }
}

Ausgabe

I am an animal My name is Rohu

Dog erbt das name Feld und die Display() Methode von Animal. Die abgeleitete Klasse kann auch eigene Member hinzufügen, wie GetName().

---

Die "is-a" Beziehung

Vererbung repräsentiert eine "is-a" Beziehung. Nutzen Sie sie, wenn eine Klasse logisch eine spezialisierte Form einer anderen ist.

• Dog ist ein Animal
• Apple ist ein Fruit
• Car ist ein Vehicle

Diese Beziehungen rechtfertigen das Ableiten von Dog von Animal, Apple von Fruit und Car von Vehicle.

---

Geschützte Member in der Vererbung

Wenn ein Feld oder eine Methode als protected deklariert wird, ist es innerhalb der eigenen Klasse und aller abgeleiteten Klassen zugänglich, aber vor externem Code verborgen.

Beispiel: Geschützte Methoden verwenden

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

Ausgabe

I can eat

Da Eat() protected ist, kann die Dog Klasse sie aufrufen, aber Code außerhalb der Hierarchie nicht.

---

Vererbungstypen

Vererbung manifestiert sich in mehreren Mustern:

1. Einfache Vererbung

Eine einzelne abgeleitete Klasse erbt von einer Basisklasse.

2. Mehrstufige Vererbung

Eine Kette, bei der eine Klasse von einer Basis erbt, dann eine weitere von dieser abgeleiteten Klasse.

3. Hierarchische Vererbung

Mehrere abgeleitete Klassen teilen dieselbe Basisklasse.

4. Mehrfache Vererbung

C# unterstützt keine Vererbung von mehreren Klassen, aber Interfaces bieten eine flexible Alternative für ähnliches Verhalten.

5. Hybridvererbung

Kombination von zwei oder mehr Vererbungstypen, z.B. mehrstufig plus hierarchisch.

---

Methodenüberschreibung

Wenn eine abgeleitete Klasse eine Methode mit derselben Signatur wie eine Basisklassenmethode deklariert, die als virtual markiert ist, kann die abgeleitete Methode sie mit override überschreiben. Dies ermöglicht polymorphes Verhalten.

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

Ausgabe

I eat dog food

Die Eat() Methode in Dog überschreibt die in Animal. virtual erlaubt den Override, override signalisiert die Substitution.

---

Das base Schlüsselwort verwenden

Manchmal müssen Sie die Basisklassenimplementierung aus einer überschreibenden Methode aufrufen. Das base Schlüsselwort ermöglicht dies.

Beispiel: Basismethoden aufrufen

using System;
namespace Inheritance {
    class Animal {
        public virtual void Eat() {
            Console.WriteLine("Animals eat food.");
        }
    }
    class Dog : Animal {
        public override void Eat() {
            base.Eat();
            Console.WriteLine("Dogs eat dog food.");
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog labrador = new Dog();
            labrador.Eat();
        }
    }
}

Ausgabe

Animals eat food. Dogs eat dog food.

Hier ruft base.Eat() die Animal Implementierung auf, bevor die abgeleitete Klassenlogik ausgeführt wird.

---

Warum Vererbung in C# wichtig ist

Vererbung ermöglicht wiederverwendbare Logik über verwandte Klassen. Betrachten Sie geometrische Formen, bei denen Umfangberechnungen eine gemeinsame Formel nutzen.

1. Erstellen Sie eine RegularPolygon Basisklasse mit CalculatePerimeter() Methode.
2. Leiten Sie Square und Rectangle davon ab, fügen Sie spezifische Eigenschaften wie Length und Sides hinzu.
3. Jede abgeleitete Klasse kann ihre eigene Flächenberechnung implementieren, während die Perimeterlogik wiederverwendet wird.

Illustratives Beispiel

using System;
namespace Inheritance {
    class RegularPolygon {
        public void CalculatePerimeter(int length, int sides) {
            int result = length * sides;
            Console.WriteLine("Perimeter: " + result);
        }
    }
    class Square : RegularPolygon {
        public int Length = 200;
        public int Sides = 4;
        public void CalculateArea() {
            int area = Length * Length;
            Console.WriteLine("Area of Square: " + 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("Area of Rectangle: " + 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);
        }
    }
}

Ausgabe

Area of Square: 40000 Perimeter: 800 Area of Rectangle: 20000 Perimeter: 400

Dieses Muster zeigt, wie Vererbung Duplikation reduziert und Wartbarkeit erhöht.