Classes abstraites

Bienvenue dans la prochaine leçon ! Dans cette leçon, vous découvrirez les classes abstraites en C#, leur utilité et ce qui les distingue des interfaces. Commençons !

Qu’est-ce qu’une classe abstraite ?

Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert de modèle pour d’autres classes et peut inclure des méthodes abstraites, que les classes dérivées doivent implémenter.

Point clé : Les classes abstraites peuvent inclure à la fois des méthodes entièrement implémentées et des méthodes seulement déclarées (méthodes abstraites).

Définir une classe abstraite

Pour définir une classe abstraite, utilisez le mot-clé abstract. Exemple :

Conseil : Utilisez les classes abstraites pour fournir une base commune aux classes apparentées.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
    public void Sleep() { // Non-abstract method
        Console.WriteLine("The animal is sleeping.");
    }
}

Implémenter une classe abstraite

Les classes dérivées doivent implémenter toutes les méthodes abstraites de la classe abstraite. Exemple :

Point clé : Les méthodes abstraites définissent un comportement que les classes dérivées doivent implémenter.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
    public void Sleep() {
        Console.WriteLine("The animal is sleeping.");
    }
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Program {
    static void Main() {
        Dog myDog = new Dog();
        myDog.Speak(); // Outputs: The dog barks.
        myDog.Sleep(); // Outputs: The animal is sleeping.
    }
}

Classes abstraites ou interfaces

Les classes abstraites et les interfaces servent toutes deux à réaliser l’abstraction, mais elles diffèrent sur plusieurs points :

• Les classes abstraites peuvent contenir des méthodes implémentées et des méthodes abstraites, tandis que les interfaces ne peuvent contenir que des méthodes abstraites (avant C# 8.0).
• Les classes abstraites peuvent inclure des champs, des constructeurs et des modificateurs d’accès pour leurs membres.
• Une classe ne peut hériter que d’une seule classe abstraite, mais elle peut implémenter plusieurs interfaces.

Conseil : Utilisez les classes abstraites pour des classes étroitement liées et les interfaces pour une abstraction plus large.

Quand utiliser les classes abstraites

Les classes abstraites sont particulièrement adaptées lorsque :

• Vous souhaitez définir une classe de base commune avec des fonctionnalités partagées.
• Vous devez inclure des méthodes non abstraites qui fournissent une implémentation par défaut.
• Vous travaillez avec des classes apparentées qui partagent une hiérarchie commune.

Exemple : Une classe abstraite « Shape » pour les classes « Circle » et « Rectangle ».

Exercice pratique

Créez une classe abstraite Shape avec une méthode abstraite CalculateArea(). Implémentez cette méthode dans les classes dérivées Rectangle et Circle. 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 = 5, Height = 4 };
        Shape circle = new Circle { Radius = 3 };

        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
        Console.WriteLine("Circle Area: " + circle.CalculateArea());
    }
}

Bonnes pratiques pour les classes abstraites

Voici quelques bonnes pratiques :

• Utilisez les classes abstraites lorsque vous disposez de fonctionnalités communes qui doivent être héritées.
• Gardez la classe abstraite ciblée et évitez d’y ajouter des membres inutiles.
• Combinez les classes abstraites avec les interfaces lorsque cela est approprié.

Conseil : Les classes abstraites doivent fournir une base solide aux classes dérivées.

Bravo !

Félicitations ! Vous avez appris à utiliser les classes abstraites pour définir des comportements communs et imposer une cohérence entre les classes dérivées. Dans la prochaine leçon, nous explorerons les membres et méthodes statiques en C#. Continuons à coder !