Methoden-Überschreiben vertieft

Teil des Abschnitts Object Oriented Programming der Python-Journey von Coddy — Lektion 23 von 64.

Polymorphismus bedeutet „viele Formen“ und ermöglicht es Objekten verschiedener Klassen, unterschiedlich auf denselben Methodenaufruf zu reagieren. Methodenüberschreibung macht dies möglich.

Hier ist eine Basisklasse mit einer Methode:

class Animal:
    def speak(self):
        return "Animal makes a sound"

Erstellen Sie Kindklassen, die dieselbe Methode überschreiben:

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Cow(Animal):
    def speak(self):
        return "Moo!"

Jede Unterklasse stellt eine eigene Implementierung von speak() bereit.

Erstellen Sie eine Liste verschiedener Tiere:

animals = [Dog(), Cat(), Cow(), Animal()]

Rufen Sie dieselbe Methode für alle Objekte auf:

for animal in animals:
    print(animal.speak())

Ausgabe:

Woof!
Meow!
Moo!
Animal makes a sound

Das ist Polymorphismus in Aktion – derselbe Methodenaufruf verhält sich je nach dem tatsächlichen Typ des Objekts unterschiedlich.

Sie können Polymorphismus auch mit Funktionen verwenden:

def make_animal_speak(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

make_animal_speak(dog)  # Wuff!
make_animal_speak(cat)  # Miau!

Die Funktion muss nicht wissen, welche Art von Tier sie erhält – sie ruft einfach speak() auf und erhält das richtige Verhalten.

Kernpunkt: Polymorphismus ermöglicht es Ihnen, verschiedene Objekte über eine gemeinsame Schnittstelle auf die gleiche Weise zu behandeln. Methodenüberschreibung bietet verschiedene Implementierungen, während Polymorphismus es Ihnen ermöglicht, diese einheitlich aufzurufen. Dies macht den Code flexibler und einfacher zu erweitern.

Aufgabe

Mittel

In dieser Herausforderung wirst du ein Fahrzeug-Vererbungssystem implementieren.

Du musst diese Dateien bearbeiten:

vehicle.py: Implementiere die Basisklasse Vehicle mit make/model-Attributen und Methoden
car.py: Erstelle die Klasse Car, die von Vehicle erbt
motorcycle.py: Erstelle die Klasse Motorcycle, die von Vehicle erbt
truck.py: Erstelle die Klasse Truck, die von Vehicle erbt

Jede Datei enthält detaillierte TODO-Kommentare, die dich Schritt für Schritt durch deine Implementierung führen. Achte auf die erforderlichen Import-Anweisungen zwischen den Dateien und folge den Vererbungsbeziehungen. Die Datei driver.py enthält Testfälle, die überprüfen, ob deine Implementierung für alle Fahrzeugtypen korrekt funktioniert.

Spickzettel

Polymorphismus ermöglicht es Objekten verschiedener Klassen, durch das Überschreiben von Methoden unterschiedlich auf denselben Methodenaufruf zu reagieren.

Erstellen Sie eine Elternklasse mit einer Methode:

class Animal:
    def speak(self):
        return "Animal makes a sound"

Kindklassen überschreiben dieselbe Methode:

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

Rufen Sie dieselbe Methode für verschiedene Objekte auf:

animals = [Dog(), Cat(), Animal()]
for animal in animals:
    print(animal.speak())  # Jedes gibt eine andere Ausgabe aus

Verwenden Sie Polymorphismus mit Funktionen:

def make_animal_speak(animal):
    print(animal.speak())

make_animal_speak(Dog())  # Woof!
make_animal_speak(Cat())  # Meow!

Polymorphismus ermöglicht es Ihnen, verschiedene Objekte über eine gemeinsame Schnittstelle auf dieselbe Weise zu behandeln, was den Code flexibler und einfacher erweiterbar macht.

Probier es selbst

from vehicle import Vehicle
from car import Car
from motorcycle import Motorcycle
from truck import Truck

def vehicle_info(vehicle):
    return f"{vehicle.make} {vehicle.model}: {vehicle.start()}, Efficiency: {vehicle.fuel_efficiency()} mpg"


# Test mit verschiedenen Fahrzeugen - DIESEN TESTCODE NICHT ÄNDERN
vehicles = [
    Car("Toyota", "Camry"),
    Motorcycle("Harley", "Davidson"),
    Truck("Ford", "F-150"),
    Vehicle("Generic", "Vehicle")
]

for v in vehicles:
    print(vehicle_info(v))