Maîtriser l'héritage C# : Concepts, types et code pratique

Héritage C# Expliqué

Ce guide couvre les fondamentaux de l'héritage en C#, ses diverses formes et des exemples de code pratiques.

L'héritage en C# vous permet de créer une nouvelle classe qui dérive d'une existante, formant une relation parent (base) et enfant (dérivée). Cette fonctionnalité puissante de la Programmation Orientée Objet (POO) favorise la réutilisation du code et l'organisation logique.

La classe de base fournit des champs, propriétés et méthodes que la classe dérivée hérite, permettant à l'enfant d'étendre ou personnaliser le comportement tout en gardant la logique partagée en un seul endroit.

---

Comment déclarer l'héritage en C#

En C#, les deux-points (:) indiquent l'héritage :

class Animal {
    // champs et méthodes
}
// Chien hérite d'Animal
class Chien : Animal {
    // champs et méthodes d'Animal
    // champs et méthodes de Chien
}

Ici, Chien étend Animal, accédant à ses membres. Le diagramme ci-dessous illustre la relation.

---

Exemple : Héritage de base

using System;
namespace Inheritance {
    // Classe de base
    class Animal {
        public string nom;
        public void Afficher() {
            Console.WriteLine("Je suis un animal");
        }
    }
    // Classe dérivée
    class Chien : Animal {
        public void ObtenirNom() {
            Console.WriteLine("Mon nom est " + nom);
        }
    }
    class Program {
        static void Main(string[] args) {
            Chien labrador = new Chien();
            labrador.nom = "Rohu";
            labrador.Afficher();
            labrador.ObtenirNom();
            Console.ReadLine();
        }
    }
}

Sortie

Je suis un animal
Mon nom est Rohu

Dans cet exemple, Chien hérite du champ nom et de la méthode Afficher() de Animal. La classe dérivée peut aussi ajouter ses propres membres, comme ObtenirNom().

---

La relation « est-un »

L'héritage représente une relation « est-un ». Utilisez-le quand une classe est logiquement une forme spécialisée d'une autre.

• Chien est un Animal
• Pomme est un Fruit
• Voiture est un Véhicule

Ces relations justifient de dériver Chien de Animal, Pomme de Fruit et Voiture de Véhicule.

---

Membres Protected dans l'héritage

Quand un champ ou méthode est déclaré protected, il est accessible dans sa propre classe et toutes les classes dérivées, mais masqué du code externe.

Exemple : Utilisation de méthodes Protected

using System;
namespace Inheritance {
    class Animal {
        protected void Manger() {
            Console.WriteLine("Je peux manger");
        }
    }
    class Chien : Animal {
        static void Main(string[] args) {
            Chien labrador = new Chien();
            labrador.Manger();
            Console.ReadLine();
        }
    }
}

Sortie

Je peux manger

Puisque Manger() est protected, la classe Chien peut l'invoquer, mais le code en dehors de la hiérarchie ne peut pas.

---

Types d'héritage

L'héritage se manifeste selon plusieurs patterns :

1. Héritage simple

Une seule classe dérivée hérite d'une classe de base.

2. Héritage multiniveau

Une chaîne d'héritage où une classe hérite d'une base, puis une autre classe hérite de cette classe dérivée.

3. Héritage hiérarchique

Plusieurs classes dérivées partagent la même classe de base.

4. Héritage multiple

Bien que C# ne supporte pas l'héritage de plusieurs classes, les interfaces fournissent une alternative flexible pour obtenir un comportement similaire.

5. Héritage hybride

Une combinaison de deux ou plusieurs types d'héritage, comme multiniveau plus hiérarchique.

---

Surcharge de méthode (Method Overriding)

Quand une classe dérivée déclare une méthode avec la même signature qu'une méthode de classe de base marquée virtual, la méthode dérivée peut la surcharger en utilisant override. Cela permet un comportement polymorphe.

using System;
namespace Inheritance {
    class Animal {
        public virtual void Manger() {
            Console.WriteLine("Je mange de la nourriture");
        }
    }
    class Chien : Animal {
        public override void Manger() {
            Console.WriteLine("Je mange de la nourriture pour chien");
        }
    }
    class Program {
        static void Main(string[] args) {
            Chien labrador = new Chien();
            labrador.Manger();
        }
    }
}

Sortie

Je mange de la nourriture pour chien

La méthode Manger() dans Chien surcharge celle dans Animal. Le mot-clé virtual permet la surcharge, tandis que override signale la substitution.

---

Utilisation du mot-clé base

Parfois vous avez besoin d'invoquer l'implémentation de la classe de base depuis une méthode surchargée. Le mot-clé base facilite cela.

Exemple : Appel des méthodes de base

using System;
namespace Inheritance {
    class Animal {
        public virtual void Manger() {
            Console.WriteLine("Les animaux mangent de la nourriture.");
        }
    }
    class Chien : Animal {
        public override void Manger() {
            base.Manger();
            Console.WriteLine("Les chiens mangent de la nourriture pour chien.");
        }
    }
    class Program {
        static void Main(string[] args) {
            Chien labrador = new Chien();
            labrador.Manger();
        }
    }
}

Sortie

Les animaux mangent de la nourriture.
Les chiens mangent de la nourriture pour chien.

Ici, base.Manger() appelle l'implémentation Animal avant d'exécuter la logique de la classe dérivée.

---

Pourquoi l'héritage est important en C#

L'héritage permet une logique réutilisable à travers des classes liées. Considérez des formes géométriques où les calculs de périmètre partagent une formule commune.

1. Créez une classe de base PolygoneRegulier avec une méthode CalculerPerimetre().
2. Dérivez Carré et Rectangle de celle-ci, ajoutant des propriétés spécifiques comme Longueur et Côtés.
3. Chaque classe dérivée peut aussi implémenter son propre calcul d'aire tout en réutilisant la logique de périmètre.

Exemple illustratif

using System;
namespace Inheritance {
    class PolygoneRegulier {
        public void CalculerPerimetre(int longueur, int cotes) {
            int resultat = longueur * cotes;
            Console.WriteLine("Périmètre : " + resultat);
        }
    }
    class Carre : PolygoneRegulier {
        public int Longueur = 200;
        public int Cotes = 4;
        public void CalculerAire() {
            int aire = Longueur * Longueur;
            Console.WriteLine("Aire du Carré : " + aire);
        }
    }
    class Rectangle : PolygoneRegulier {
        public int Longueur = 100;
        public int Largeur = 200;
        public int Cotes = 4;
        public void CalculerAire() {
            int aire = Longueur * Largeur;
            Console.WriteLine("Aire du Rectangle : " + aire);
        }
    }
    class Program {
        static void Main(string[] args) {
            Carre c1 = new Carre();
            c1.CalculerAire();
            c1.CalculerPerimetre(c1.Longueur, c1.Cotes);
            Rectangle r1 = new Rectangle();
            r1.CalculerAire();
            r1.CalculerPerimetre(r1.Longueur, r1.Cotes);
        }
    }
}

Sortie

Aire du Carré : 40000
Périmètre : 800
Aire du Rectangle : 20000
Périmètre : 400

Ce pattern illustre comment l'héritage réduit la duplication et améliore la maintenabilité.