Polymorphie und Methodenüberschreibung

Willkommen zur nächsten Lektion! In dieser Lektion lernen Sie Polymorphie kennen, ein grundlegendes Konzept der objektorientierten Programmierung, und erfahren, wie Sie Methoden überschreiben, um flexiblen und wiederverwendbaren Code zu schreiben. Legen wir los!

Was ist Polymorphie?

Polymorphie bedeutet „viele Formen“ und ermöglicht es, Objekte verschiedener Klassen als Objekte einer gemeinsamen Basisklasse zu behandeln. Dadurch wird Ihr Code flexibler und wiederverwendbarer.

Beispiel: Eine Methode kann sich je nach Typ des Objekts, mit dem sie arbeitet, unterschiedlich verhalten.

Wichtiger Punkt: Polymorphie wird in C# durch Methodenüberschreibung und Schnittstellen erreicht.

Methodenüberschreibung verstehen

Die Methodenüberschreibung ermöglicht es einer abgeleiteten Klasse, eine spezifische Implementierung einer Methode bereitzustellen, die bereits in ihrer Basisklasse definiert ist. Verwenden Sie das Schlüsselwort virtual in der Basisklasse und das Schlüsselwort override in der abgeleiteten Klasse. Beispiel:

Tipp: Die Methodenüberschreibung stellt sicher, dass unabhängig vom Referenztyp des Objekts die richtige Methode aufgerufen wird.

using System;

class Animal {
    public virtual void Speak() {
        Console.WriteLine("The animal makes a sound.");
    }
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Cat : Animal {
    public override void Speak() {
        Console.WriteLine("The cat meows.");
    }
}

class Program {
    static void Main() {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.Speak(); // Outputs: The dog barks.
        myCat.Speak(); // Outputs: The cat meows.
    }
}

Polymorphie verwenden

Polymorphie ermöglicht es Ihnen, Code zu schreiben, der über eine gemeinsame Schnittstelle mit Objekten unterschiedlicher Typen funktioniert. Beispiel:

Wichtiger Punkt: Mit Polymorphie können Sie allgemeineren und wiederverwendbaren Code schreiben.

using System;

class Animal {
    public virtual void Speak() {
        Console.WriteLine("The animal makes a sound.");
    }
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Cat : Animal {
    public override void Speak() {
        Console.WriteLine("The cat meows.");
    }
}

class Program {
    static void Main() {
        Animal[] animals = { new Dog(), new Cat() };

        foreach (Animal animal in animals) {
            animal.Speak(); // Calls the appropriate method for each object
        }
    }
}

Das Schlüsselwort base bei der Überschreibung verwenden

Mit dem Schlüsselwort base wird eine Methode der Basisklasse aus der überschriebenen Methode heraus aufgerufen. Beispiel:

Tipp: Verwenden Sie base, wenn Sie die Funktionalität der Basisklasse in einer überschriebenen Methode beibehalten möchten.

using System;

class Animal {
    public virtual void Speak() {
        Console.WriteLine("The animal makes a sound.");
    }
}

class Dog : Animal {
    public override void Speak() {
        base.Speak(); // Calls the base class method
        Console.WriteLine("The dog barks.");
    }
}

class Program {
    static void Main() {
        Dog myDog = new Dog();
        myDog.Speak(); // Outputs: The animal makes a sound. The dog barks.
    }
}

Abstrakte Klassen und Methoden

Abstrakte Klassen dienen als Vorlage für abgeleitete Klassen. Sie können abstrakte Methoden enthalten, die in der abgeleiteten Klasse überschrieben werden müssen. Beispiel:

Wichtiger Punkt: Abstrakte Methoden erzwingen, dass abgeleitete Klassen ihre eigene Implementierung bereitstellen.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Program {
    static void Main() {
        Animal myDog = new Dog();
        myDog.Speak(); // Outputs: The dog barks.
    }
}

Übungsaufgabe

Erstellen Sie eine abstrakte Klasse Shape mit einer abstrakten Methode CalculateArea(). Erstellen Sie die abgeleiteten Klassen Rectangle und Circle, die CalculateArea() implementieren. Beispiel:

using System;

abstract class Shape {
    public abstract double CalculateArea();
}

class Rectangle : Shape {
    public double Width { get; set; }
    public double Height { get; set; }

    public override double CalculateArea() {
        return Width * Height;
    }
}

class Circle : Shape {
    public double Radius { get; set; }

    public override double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

class Program {
    static void Main() {
        Shape rectangle = new Rectangle { Width = 4, Height = 5 };
        Shape circle = new Circle { Radius = 3 };

        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
        Console.WriteLine("Circle Area: " + circle.CalculateArea());
    }
}

Bewährte Vorgehensweisen bei Polymorphie

Hier sind einige bewährte Vorgehensweisen:

• Verwenden Sie Polymorphie, um Code zu vereinfachen und Duplikate zu vermeiden.
• Überschreiben Sie nur Methoden, die in abgeleiteten Klassen ein spezifisches Verhalten erfordern.
• Verwenden Sie abstrakte Klassen und Methoden für gemeinsame Schnittstellen in abgeleiteten Klassen.

Tipp: Polymorphie macht Ihren Code leichter erweiterbar und wartbar.

Gute Arbeit!

Herzlichen Glückwunsch! Sie haben gelernt, wie Sie Polymorphie und Methodenüberschreibung verwenden, um flexiblen und wiederverwendbaren Code zu schreiben. In der nächsten Lektion beschäftigen wir uns mit der Arbeit mit Schnittstellen, um Abstraktion zu erreichen und mehrere Verhaltensweisen zu implementieren. Programmieren wir weiter!