Introduction aux interfaces

Bienvenue dans la première leçon sur les concepts avancés de programmation ! Dans cette leçon, vous découvrirez les interfaces, leur utilité et la manière de les utiliser pour parvenir à l’abstraction et à la flexibilité dans vos programmes C#. Commençons !

Qu’est-ce qu’une interface ?

Une interface est un contrat qui définit un ensemble de méthodes et de propriétés qu’une classe doit implémenter. Elle ne fournit aucune implémentation, mais garantit que toute classe qui l’implémente respecte une conception spécifique.

Exemple : Une interface pour un « Vehicle » pourrait définir des méthodes comme Start() et Stop(), que tous les véhicules doivent implémenter.

Point clé : Les interfaces permettent de concevoir du code flexible et réutilisable en séparant le comportement de l’implémentation.

Définir une interface

Pour définir une interface en C#, utilisez le mot-clé interface. Exemple :

Conseil : Par convention, les noms d’interfaces en C# commencent par la lettre I.

using System;

interface IVehicle {
    void Start();
    void Stop();
}

Implémenter une interface

Pour implémenter une interface, une classe doit définir toutes les méthodes et propriétés déclarées dans l’interface. Exemple :

Point clé : Une classe peut implémenter plusieurs interfaces afin de prendre en charge plusieurs comportements.

using System;

interface IVehicle {
    void Start();
    void Stop();
}

class Car : IVehicle {
    public void Start() {
        Console.WriteLine("Car is starting.");
    }

    public void Stop() {
        Console.WriteLine("Car is stopping.");
    }
}

class Program {
    static void Main() {
        IVehicle myCar = new Car();
        myCar.Start();
        myCar.Stop();
    }
}

Pourquoi utiliser des interfaces ?

Les interfaces présentent plusieurs avantages :

• Abstraction : Définir un comportement sans en préciser l’implémentation.
• Flexibilité : Une classe peut implémenter plusieurs interfaces, ce qui lui permet d’assumer plusieurs rôles.
• Cohérence : Imposer une structure commune aux classes apparentées.

Conseil : Utilisez les interfaces lorsque vous souhaitez définir un contrat commun sans imposer la manière dont il doit être respecté.

Combiner plusieurs interfaces

Une classe peut implémenter plusieurs interfaces afin de combiner différents ensembles de comportements. Exemple :

using System;

interface IVehicle {
    void Start();
    void Stop();
}

interface IRadio {
    void PlayMusic();
}

class Car : IVehicle, IRadio {
    public void Start() {
        Console.WriteLine("Car is starting.");
    }

    public void Stop() {
        Console.WriteLine("Car is stopping.");
    }

    public void PlayMusic() {
        Console.WriteLine("Playing music.");
    }
}

class Program {
    static void Main() {
        Car myCar = new Car();
        myCar.Start();
        myCar.PlayMusic();
        myCar.Stop();
    }
}

Exercice pratique

Créez une interface IShape avec une méthode CalculateArea(). Implémentez cette interface dans les classes Rectangle et Circle. Exemple :

using System;

interface IShape {
    double CalculateArea();
}

class Rectangle : IShape {
    public double Width { get; set; }
    public double Height { get; set; }

    public double CalculateArea() {
        return Width * Height;
    }
}

class Circle : IShape {
    public double Radius { get; set; }

    public double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

class Program {
    static void Main() {
        IShape rectangle = new Rectangle { Width = 5, Height = 4 };
        IShape circle = new Circle { Radius = 3 };

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

Bonnes pratiques pour l’utilisation des interfaces

Voici quelques bonnes pratiques :

• Utilisez les interfaces pour définir les contrats que les classes doivent respecter.
• Préférez les interfaces à l’héritage pour des classes sans lien qui partagent un comportement commun.
• Gardez les interfaces ciblées et évitez d’y inclure des méthodes ou des propriétés inutiles.

Conseil : Les interfaces doivent décrire ce qu’une classe fait, et non comment elle le fait.

Bravo !

Félicitations ! Vous avez appris les bases des interfaces et comment les utiliser pour parvenir à l’abstraction et à la flexibilité dans vos programmes. Dans la prochaine leçon, nous nous pencherons sur les classes abstraites et apprendrons ce qui les distingue des interfaces. Continuons à coder !