Maîtriser l'Héritage et le Polymorphisme en C# : Exemples de Code Pratiques

Qu'est-ce que l'Héritage en C# ?

L'héritage est une pierre angulaire de la conception orientée objet en C#. Il permet à une classe enfant de recevoir automatiquement les champs et méthodes d'une classe parente, tout en permettant à l'enfant de redéfinir ou d'étendre ce comportement. Cela favorise la réutilisation du code, simplifie la maintenance et établit une hiérarchie claire.

• Définit les classes parent et enfant.
• L'enfant hérite des membres du parent.
• L'enfant peut modifier le comportement hérité.
• L'enfant peut ajouter ses propres membres.

Exemple d'Héritage en C#

Ci-dessous, une démonstration étape par étape montrant comment implémenter l'héritage et utiliser des membres protégés.

Étape 1 – Modifier la Classe de Base

Ouvrez Tutoriel.cs et modifiez la classe Tutoriel pour que ses champs clés soient protected :

L'utilisation de protected garantit que seules les classes dérivées peuvent accéder directement à ces champs.

Étape 2 – Créer une Classe Dérivée

Ajoutez le code suivant à Tutoriel.cs après la définition de la classe de base :

Explication :

1. Déclarer Guru99Tutoriel comme enfant de Tutoriel en utilisant la syntaxe deux-points (:).
2. Ajouter une méthode RenommerTutoriel qui assigne une nouvelle valeur à TutorialName.
3. Puisque TutorialName est protected, Guru99Tutoriel peut y accéder même s'il n'est pas explicitement déclaré là.

Étape 3 – Utiliser la Classe Dérivée dans Program.cs

Remplacez le contenu de Program.cs par le suivant :

using System;
namespace DemoApplication {
    public class Tutoriel {
        protected int TutorialID;
        protected string TutorialName;
        public void SetTutorial(int pID, string pName) {
            TutorialID = pID;
            TutorialName = pName;
        }
        public string GetTutorial() {
            return TutorialName;
        }
    }
    public class Guru99Tutoriel : Tutoriel {
        public void RenommerTutoriel(string pNewName) {
            TutorialName = pNewName;
        }
        static void Main(string[] args) {
            Guru99Tutoriel pTutor = new Guru99Tutoriel();
            pTutor.RenommerTutoriel(".Net par Guru99");
            Console.WriteLine(pTutor.GetTutorial());
            Console.ReadKey();
        }
    }
}

Explication :

1. Le programme instancie Guru99Tutoriel, pas la classe de base Tutoriel.
2. Il appelle RenommerTutoriel pour changer le titre.
3. Même si GetTutorial est défini dans la classe de base, l'instance dérivée peut l'invoquer directement.

L'exécution de ce code affiche :

Qu'est-ce que le Polymorphisme en C# ?

Le polymorphisme permet à une seule interface de représenter différentes formes sous-jacentes. En C#, cela se manifeste souvent par la surcharge ou la redéfinition de méthodes, permettant au même nom de méthode d'effectuer des tâches variées selon les paramètres ou le contexte.

Exemple de Polymorphisme en C#

Nous démontrerons la surcharge de méthode au sein de la même classe.

Étape 1 – Mettre à Jour la Classe de Base

Modifiez Tutoriel.cs comme indiqué :

Changements clés :

1. La méthode SetTutorial a maintenant deux surcharges – une qui accepte un int et un string, et une autre qui accepte seulement un string.
2. Les deux surcharges assignent des valeurs aux champs correspondants.

Étape 2 – Tester dans Program.cs

Remplacez Program.cs par le code suivant :

using System;
namespace DemoApplication {
    class Tutoriel {
        public int TutorialID;
        public string TutorialName;
        public void SetTutorial(int pID, string pName) {
            TutorialID = pID;
            TutorialName = pName;
        }
        public void SetTutorial(string pName) {
            TutorialName = pName;
        }
        public string GetTutorial() {
            return TutorialName;
        }
        static void Main(string[] args) {
            Tutoriel pTutor = new Tutoriel();
            pTutor.SetTutorial(1, "Premier Tutoriel");
            Console.WriteLine(pTutor.GetTutorial());
            pTutor.SetTutorial("Second Tutoriel");
            Console.WriteLine(pTutor.GetTutorial());
            Console.ReadKey();
        }
    }
}

Explication :

1. Le premier appel passe à la fois id et name à la surcharge à deux paramètres.
2. Le second appel passe seulement name, invoquant la surcharge à un paramètre.

La console affiche :

Pour des scénarios avancés, vous pouvez ajouter une méthode GetTutorialID pour récupérer l'ID séparément.

Résumé

• L'héritage permet à une classe enfant d'hériter et d'étendre les membres du parent.
• Le polymorphisme, surtout la surcharge de méthode, permet à un seul nom de méthode de s'adapter à différents jeux de paramètres.
• Les deux concepts sont essentiels pour un code C# propre, maintenable et réutilisable.