Retour sur la redéfinition de méthode

Fait partie de la section Object Oriented Programming du Journey Python de Coddy — leçon 23 sur 64.

Le polymorphisme signifie « plusieurs formes » et permet à des objets de différentes classes de répondre différemment au même appel de méthode. La redéfinition de méthode rend cela possible.

Voici une classe parente avec une méthode :

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

Créez des classes enfants qui surchargent la même méthode :

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

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

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

Chaque classe enfant fournit sa propre implémentation de speak().

Créez une liste de différents animaux :

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

Appelez la même méthode sur tous les objets :

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

Sortie :

Woof!
Meow!
Moo!
Animal makes a sound

C'est le polymorphisme en action - le même appel de méthode se comporte différemment en fonction du type réel de l'objet.

Vous pouvez également utiliser le polymorphisme avec des fonctions :

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

dog = Dog()
cat = Cat()

make_animal_speak(dog)  # Wouf !
make_animal_speak(cat)  # Miaou !

La fonction n'a pas besoin de savoir quel type d'animal elle reçoit - elle appelle simplement speak() et obtient le comportement approprié.

Point clé : Le polymorphisme vous permet de traiter différents objets de la même manière via une interface commune. La redéfinition de méthode fournit différentes implémentations, tandis que le polymorphisme vous permet de les appeler de manière uniforme. Cela rend le code plus flexible et plus facile à étendre.

Défi

Moyen

Dans ce défi, vous allez implémenter un système d'héritage de véhicules.

Vous devrez modifier ces fichiers :

vehicle.py : Implémentez la classe de base Vehicle avec les attributs make/model et des méthodes
car.py : Créez la classe Car qui hérite de Vehicle
motorcycle.py : Créez la classe Motorcycle qui hérite de Vehicle
truck.py : Créez la classe Truck qui hérite de Vehicle

Chaque fichier contient des commentaires TODO détaillés pour guider votre implémentation étape par étape. Faites attention aux instructions d'importation nécessaires entre les fichiers et respectez les relations d'héritage. Le fichier driver.py contient des cas de test qui vérifieront que votre implémentation fonctionne correctement pour tous les types de véhicules.

Aide-mémoire

Le polymorphisme permet à des objets de différentes classes de répondre différemment au même appel de méthode grâce à la redéfinition de méthode.

Créez une classe parente avec une méthode :

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

Les classes enfants redéfinissent la même méthode :

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

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

Appelez la même méthode sur différents objets :

animals = [Dog(), Cat(), Animal()]
for animal in animals:
    print(animal.speak())  # Chaque appel affiche un résultat différent

Utilisez le polymorphisme avec des fonctions :

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

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

Le polymorphisme vous permet de traiter différents objets de la même manière via une interface commune, ce qui rend le code plus flexible et plus facile à étendre.

Essayez vous-même

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"


# Tester avec différents véhicules - NE PAS MODIFIER CE CODE DE TEST
vehicles = [
    Car("Toyota", "Camry"),
    Motorcycle("Harley", "Davidson"),
    Truck("Ford", "F-150"),
    Vehicle("Generic", "Vehicle")
]

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