Héritage : réutiliser le code

Bienvenue dans la prochaine leçon ! Vous allez découvrir l’héritage, l’un des principes fondamentaux de la programmation orientée objet, ainsi que la manière dont il permet de réutiliser le code et de créer des hiérarchies. Commençons !

Qu’est-ce que l’héritage ?

L’héritage permet à une classe (la classe enfant ou classe dérivée) d’acquérir les attributs et les méthodes d’une autre classe (la classe parent ou classe de base). Il permet de réutiliser le code et d’établir des relations hiérarchiques entre les classes.

Exemple : Une classe « Car » peut servir de classe de base aux classes « ElectricCar » et « SportsCar », en partageant des propriétés communes comme « Couleur » et « Vitesse ».

Définir une classe de base

Une classe de base contient des propriétés et des méthodes communes qui peuvent être héritées par les classes dérivées. Exemple :

Point clé : Définissez le code réutilisable dans la classe de base.

using System;

class Vehicle {
    public string Color;

    public void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

Créer une classe dérivée

Une classe dérivée hérite des propriétés et des méthodes d’une classe de base. Utilisez le symbole : pour indiquer l’héritage. Exemple :

Point clé : Les classes dérivées peuvent ajouter de nouvelles fonctionnalités ou remplacer le comportement de la classe de base.

using System;

class Vehicle {
    public string Color;

    public void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

class Car : Vehicle {
    public int NumberOfDoors;

    public void ShowDetails() {
        Console.WriteLine("Color: " + Color);
        Console.WriteLine("Doors: " + NumberOfDoors);
    }
}

class Program {
    static void Main() {
        Car myCar = new Car();
        myCar.Color = "Red"; // Inherited from Vehicle
        myCar.NumberOfDoors = 4;
        myCar.Drive(); // Inherited from Vehicle
        myCar.ShowDetails();
    }
}

Remplacer des méthodes

Les classes dérivées peuvent remplacer les méthodes de la classe de base afin de fournir un comportement spécialisé. Utilisez le mot-clé virtual dans la classe de base et le mot-clé override dans la classe dérivée. Exemple :

Conseil : Le remplacement est utile pour personnaliser le comportement des classes dérivées.

using System;

class Vehicle {
    public virtual void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

class SportsCar : Vehicle {
    public override void Drive() {
        Console.WriteLine("The sports car is driving fast!");
    }
}

class Program {
    static void Main() {
        SportsCar myCar = new SportsCar();
        myCar.Drive(); // Calls the overridden method
    }
}

Mot-clé de base

Le mot-clé base permet d’accéder aux membres de la classe de base depuis une classe dérivée. Exemple :

Conseil : Utilisez base pour étendre ou compléter le comportement de la classe de base.

using System;

class Vehicle {
    public string Color;

    public virtual void Drive() {
        Console.WriteLine("The vehicle is driving.");
    }
}

class Truck : Vehicle {
    public override void Drive() {
        base.Drive(); // Calls the base class method
        Console.WriteLine("The truck is carrying a heavy load.");
    }
}

class Program {
    static void Main() {
        Truck myTruck = new Truck();
        myTruck.Color = "Blue";
        myTruck.Drive();
    }
}

Exercice pratique

Créez une classe de base appelée Animal avec une méthode Speak() qui affiche « L’animal émet un son. » Créez des classes dérivées Dog et Cat qui redéfinissent Speak() pour afficher « Le chien aboie. » et « Le chat miaule. » Exemple :

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

Bonnes pratiques de l’héritage

Voici quelques bonnes pratiques :

• Utilisez l’héritage uniquement lorsqu’il existe une relation claire « est-un » (par ex., un Car est un Vehicle).
• Gardez les classes de base aussi générales que possible.
• Utilisez sealed pour empêcher tout nouvel héritage si nécessaire.

Conseil : L’héritage doit simplifier votre base de code, et non la compliquer.

Bravo !

Félicitations ! Vous avez appris à utiliser l’héritage pour réutiliser du code et construire des hiérarchies de classes en C#. Dans la prochaine leçon, nous nous pencherons sur le polymorphisme, un autre concept puissant de la programmation orientée objet. Continuons à coder !