Redéfinition de méthode

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

La redéfinition de méthode permet à une classe enfant de fournir sa propre implémentation d'une méthode qui existe déjà dans la classe parente.

Voici un exemple d'une classe parente avec des méthodes :

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        print("Some generic animal sound")
    
    def info(self):
        print(f"I am {self.name}")

Créez une classe enfant qui surcharge une méthode :

class Dog(Animal):
    def make_sound(self):
        print("Woof! Woof!")  # Surcharge la méthode parente

La méthode make_sound dans Dog remplace celle de Animal, mais info est toujours héritée sans modification.

Créez des instances et testez les méthodes :

animal = Animal("Generic Animal")
dog = Dog("Buddy")

Appelez la méthode redéfinie :

animal.make_sound()
dog.make_sound()

Appelez la méthode non redéfinie :

animal.info()
dog.info()

Sortie :

Some generic animal sound
Woof! Woof!
I am Generic Animal
I am Buddy

Vous pouvez surcharger n'importe quelle méthode héritée :

class Cat(Animal):
    def make_sound(self):
        print("Meow!")
    
    def info(self):
        print(f"I am {self.name}, a sneaky cat")

cat = Cat("Whiskers")
cat.make_sound()
cat.info()

Sortie :

Meow!
I am Whiskers, a sneaky cat

Point clé : La redéfinition de méthode permet aux classes enfants de personnaliser le comportement hérité. Il suffit de définir une méthode avec le même nom dans la classe enfant. La version de l'enfant sera utilisée à la place de celle du parent.

Défi

Moyen

Dans ce défi, vous allez implémenter une hiérarchie de formes.

shape.py - Contient la classe parente Shape avec l'attribut color et des méthodes
circle.py - Contient la classe Circle qui hérite de Shape
square.py - Contient la classe Square qui hérite de Shape

Chaque fichier contient des commentaires TODO détaillés qui vous guideront étape par étape tout au long de l'implémentation.

Aide-mémoire

La redéfinition de méthode (method overriding) permet à une classe enfant de fournir sa propre implémentation d'une méthode qui existe déjà dans la classe parente.

Exemple de classe parente :

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        print("Some generic animal sound")
    
    def info(self):
        print(f"I am {self.name}")

Classe enfant redéfinissant une méthode :

class Dog(Animal):
    def make_sound(self):
        print("Woof! Woof!")  # Redéfinir la méthode parente

La méthode make_sound dans Dog remplace celle d'Animal, mais info est toujours héritée sans modification.

Vous pouvez redéfinir plusieurs méthodes :

class Cat(Animal):
    def make_sound(self):
        print("Meow!")
    
    def info(self):
        print(f"I am {self.name}, a sneaky cat")

Point clé : Définissez simplement une méthode avec le même nom dans la classe enfant. La version de l'enfant sera utilisée à la place de celle du parent.

Essayez vous-même

from shape import Shape
from circle import Circle
from square import Square

# Gestionnaire de cas de test
test_case = input()

if test_case == "base_shape":
    # Tester la classe de base Shape
    shape = Shape("green")
    print(f"Color: {shape.color}")
    print(f"Area: {shape.area()}")
    print("Describe output:")
    shape.describe()

elif test_case == "circle_basics":
    # Tester la création de Circle et les méthodes de base
    circle = Circle("red", 5)
    print(f"Color: {circle.color}")
    print(f"Radius: {circle.radius}")
    print(f"Area (rounded): {round(circle.area(), 2)}")
    print("Describe output:")
    circle.describe()

elif test_case == "square_basics":
    # Tester la création de Square et les méthodes de base
    square = Square("blue", 4)
    print(f"Color: {square.color}")
    print(f"Side length: {square.side_length}")
    print(f"Area: {square.area()}")
    print("Describe output:")
    square.describe()

elif test_case == "various_sizes":
    # Tester plusieurs instances avec des dimensions différentes
    shapes = [
        Circle("yellow", 2),
        Circle("orange", 7.5),
        Square("purple", 3),
        Square("black", 10)
    ]
    
    for i, shape in enumerate(shapes, 1):
        print(f"Shape {i}:")
        shape.describe()
        print(f"Area: {round(shape.area(), 2)}")
        print()  # Ligne vide pour la lisibilité

elif test_case == "shape_polymorphism":
    # Tester le comportement polymorphe avec une liste de formes
    shapes = [
        Shape("white"),
        Circle("red", 3),
        Square("blue", 4)
    ]
    
    print("Polymorphic behavior demonstration:")
    for shape in shapes:
        shape.describe()
        print(f"Area: {round(shape.area(shape_polymorphism), 2)}")
        print()  # Ligne vide pour la lisibilité

elif test_case == "original_test_case":
    # Exécuter le code de test original du défi
    circle = Circle("red", 5)
    square = Square("blue", 4)

    # Tester la méthode describe
    circle.describe()
    square.describe()

    # Tester la méthode area
    print(f"Circle area: {circle.area()}")
    print(f"Square area: {square.area()}")