Polymorphisme et redéfinition des méthodes

Bienvenue dans la prochaine leçon ! Dans cette leçon, vous découvrirez le polymorphisme, un concept essentiel de la programmation orientée objet, ainsi que la manière dont il permet de redéfinir des méthodes pour produire un code flexible et réutilisable. Commençons !

Qu’est-ce que le polymorphisme ?

Le polymorphisme signifie « plusieurs formes » et permet de traiter des objets de classes différentes comme des objets d’une même classe de base. Cela rend votre code plus flexible et réutilisable.

Exemple : Une méthode peut se comporter différemment selon le type de l’objet avec lequel elle travaille.

Point clé : En C#, le polymorphisme s’obtient grâce à la redéfinition des méthodes et aux interfaces.

Comprendre la redéfinition des méthodes

La redéfinition d’une méthode permet à une classe dérivée de fournir une implémentation spécifique d’une méthode déjà définie dans sa classe de base. Utilisez le mot-clé virtual dans la classe de base et le mot-clé override dans la classe dérivée. Exemple :

Conseil : La redéfinition des méthodes garantit que la méthode correcte est appelée pour un objet, quel que soit son type de référence.

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.
    }
}

Utiliser le polymorphisme

Le polymorphisme permet d’écrire du code qui fonctionne avec différents types d’objets grâce à une interface commune. Exemple :

Point clé : Le polymorphisme permet d’écrire du code plus générique et réutilisable.

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
        }
    }
}

Utiliser le mot-clé base avec la redéfinition

Le mot-clé base permet d’appeler une méthode de la classe de base depuis la méthode redéfinie. Exemple :

Conseil : Utilisez base lorsque vous souhaitez conserver les fonctionnalités de la classe de base dans une méthode redéfinie.

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.
    }
}

Classes et méthodes abstraites

Les classes abstraites fournissent un modèle pour les classes dérivées. Elles peuvent inclure des méthodes abstraites, qui doivent être redéfinies dans la classe dérivée. Exemple :

Point clé : Les méthodes abstraites imposent aux classes dérivées de fournir leur propre implémentation.

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.
    }
}

Exercice pratique

Créez une classe abstraite Shape avec une méthode abstraite CalculateArea(). Dérivez les classes Rectangle et Circle afin qu’elles implémentent CalculateArea(). Exemple :

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());
    }
}

Bonnes pratiques du polymorphisme

Voici quelques bonnes pratiques :

• Utilisez le polymorphisme pour simplifier le code et éviter les duplications.
• Ne redéfinissez que les méthodes qui nécessitent un comportement particulier dans les classes dérivées.
• Utilisez les classes et méthodes abstraites pour définir des interfaces communes à plusieurs classes dérivées.

Conseil : Le polymorphisme facilite l’extension et la maintenance de votre code.

Bravo !

Félicitations ! Vous avez appris à utiliser le polymorphisme et la redéfinition des méthodes pour écrire du code flexible et réutilisable. Dans la prochaine leçon, nous explorerons l’utilisation des interfaces pour parvenir à l’abstraction et implémenter plusieurs comportements. Continuons à coder !