Grundlegende Vererbungs-(:)-Syntax

Teil des Abschnitts Objektorientierte Programmierung der C#-Journey von Coddy. Lektion 19 von 70.

Vererbung ermöglicht es einer Klasse, die Eigenschaften und Methoden einer anderen Klasse zu übernehmen. Anstatt denselben Code neu zu schreiben, erstellen Sie eine Basisklasse (Elternklasse) mit gemeinsamer Funktionalität und erstellen dann abgeleitete Klassen (Kindklassen), die von ihr erben.

In C# verwenden Sie den Doppelpunkt : als Symbol, um Vererbung anzuzeigen:

public class Animal
{
    public string Name { get; set; }
    
    public void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} says Woof!");
    }
}

Die Klasse Dog erbt alles von Animal. Sie hat Zugriff auf die Eigenschaft Name und die Methode Eat(), ohne sie erneut zu deklarieren, zudem fügt sie ihre eigene Methode Bark() hinzu:

Dog myDog = new Dog();
myDog.Name = "Buddy";
myDog.Eat();   // Ausgabe: Buddy frisst.
myDog.Bark();  // Ausgabe: Buddy sagt Wuff!

C# unterstützt nur Einzelvererbung, was bedeutet, dass eine Klasse von nur einer Basisklasse erben kann. Sie können jedoch Vererbungsketten aufbauen, bei denen eine abgeleitete Klasse zur Basis für eine andere Klasse wird. Dies schafft eine Hierarchie, die reale Beziehungen modelliert und gleichzeitig Ihren Code organisiert und wiederverwendbar hält.

Aufgabe

Einfach

Erstellen wir eine Fahrzeughierarchie, die zeigt, wie Vererbung es abgeleiteten Klassen ermöglicht, Funktionalität von einer Basisklasse gemeinsam zu nutzen und gleichzeitig ihr eigenes einzigartiges Verhalten hinzuzufügen.

Du erstellst drei Dateien, um deinen Code zu organisieren:

Vehicle.cs: Definiere eine Vehicle-Klasse im Namespace Transport. Dies wird deine Basisklasse sein, die von allen Fahrzeugen gemeinsam genutzt wird. Sie sollte eine Brand-Eigenschaft (string) und eine Year-Eigenschaft (int) sowie eine Methode StartEngine() besitzen, die "{Brand} engine started." ausgibt.
Car.cs: Definiere eine Car-Klasse im Namespace Transport, die von Vehicle erbt. Das Auto fügt seine eigene Eigenschaft NumberOfDoors (int) und eine Methode Honk() hinzu, die "{Brand} goes Beep Beep!" ausgibt.
Program.cs: Erstelle in deiner Hauptdatei eine Car-Instanz mithilfe von Eingabewerten. Lege ihre Eigenschaften fest (einschließlich der geerbten) und zeige anschließend, dass das Auto sowohl seine eigenen Methoden als auch die von Vehicle geerbten Methoden verwenden kann.

Du erhältst drei Eingaben:

Markenname
Baujahr
Anzahl der Türen

Gib die Informationen zum Auto aus und zeige seine Fähigkeiten in diesem Format:

Car: {Brand} ({Year})
Doors: {NumberOfDoors}
{StartEngine output}
{Honk output}

Wenn die Eingaben beispielsweise Toyota, 2022 und 4 lauten, sollte die Ausgabe folgendermaßen aussehen:

Car: Toyota (2022)
Doors: 4
Toyota engine started.
Toyota goes Beep Beep!

Beachte, wie dein Car auf die Eigenschaft Brand und die Methode StartEngine() zugreifen kann, obwohl sie in Vehicle definiert sind. Das ist die Stärke der Vererbung – die abgeleitete Klasse erhält automatisch alles von ihrer Basisklasse!

Probier es selbst

using System;
using Transport;

class Program
{
    public static void Main(string[] args)
    {
        // Eingabe lesen
        string brand = Console.ReadLine();
        int year = Convert.ToInt32(Console.ReadLine());
        int doors = Convert.ToInt32(Console.ReadLine());
        
        // TODO: Erstelle eine Car Instanz
        
        // TODO: Setze die Eigenschaften des Autos (Brand, Year, NumberOfDoors)
        
        // TODO: Gib die Informationen des Autos im erforderlichen Format aus:
        // Car: {Brand} ({Year})
        // Doors: {NumberOfDoors}
        // Rufe dann StartEngine() und Honk() auf
    }
}