Interfaces Multiples

Fait partie de la section Programmation Orientée Objet du Journey C# de Coddy. Leçon 27 sur 70.

Bien qu’une classe ne puisse hériter que d’une seule classe de base, elle peut implémenter autant d’interfaces que nécessaire. C’est l’un des principaux avantages des interfaces par rapport aux classes abstraites : elles permettent à une classe d’adopter plusieurs comportements.

Pour implémenter plusieurs interfaces, il suffit de les énumérer après les deux-points, séparées par des virgules :

public interface IFlyable
{
    void Fly();
}

public interface ISwimmable
{
    void Swim();
}

public class Duck : IFlyable, ISwimmable
{
    public void Fly()
    {
        Console.WriteLine("Flying through the air");
    }
    
    public void Swim()
    {
        Console.WriteLine("Swimming in the pond");
    }
}

La classe Duck doit implémenter tous les membres des deux interfaces. Cela modélise naturellement les situations du monde réel : un canard peut véritablement à la fois voler et nager, il est donc logique qu’il remplisse les deux contrats.

Lorsqu’on combine l’héritage avec plusieurs interfaces, la classe de base doit apparaître en premier :

public class Duck : Bird, IFlyable, ISwimmable
{
    // Hérite de Bird, implémente les deux interfaces
}

Cette flexibilité vous permet de composer des comportements à partir de plusieurs sources. Un Robot peut implémenter IMovable, IChargeable et ISpeakable. Chaque interface représente une seule capacité, et votre classe peut combiner exactement ce dont elle a besoin.

Défi

Facile

Construisons un système d’appareils domotiques qui montre comment une seule classe peut implémenter plusieurs interfaces afin d’acquérir différentes capacités. Vous créerez des appareils qui peuvent être contrôlés et qui disposent également de fonctionnalités de gestion de l’alimentation.

Vous organiserez votre code dans quatre fichiers :

IControllable.cs : définissez une interface appelée IControllable dans l’espace de noms SmartHome. Cette interface représente les appareils qui peuvent être allumés et éteints. Elle doit déclarer deux méthodes : TurnOn() et TurnOff(), qui renvoient toutes deux une chaîne de caractères.
INetworkConnected.cs : définissez une interface appelée INetworkConnected dans l’espace de noms SmartHome. Cette interface représente les appareils qui peuvent se connecter à un réseau. Elle doit déclarer une méthode Connect(string network) qui renvoie une chaîne de caractères.
SmartTV.cs : définissez une classe SmartTV dans l’espace de noms SmartHome qui implémente à la fois IControllable et INetworkConnected. Le téléviseur doit avoir une propriété Brand (string) et une propriété ScreenSize (int, représentant la taille en pouces). Créez un constructeur qui accepte ces deux valeurs. Implémentez toutes les méthodes des interfaces :
- TurnOn() renvoie "{Brand} {ScreenSize}-inch TV is now ON"
- TurnOff() renvoie "{Brand} {ScreenSize}-inch TV is now OFF"
- Connect(string network) renvoie "{Brand} TV connected to {network}"
Program.cs : dans votre fichier principal, créez un SmartTV à l’aide des valeurs saisies. Montrez la flexibilité de plusieurs interfaces en stockant le même objet TV dans trois types de variables différents : le type concret SmartTV, une variable IControllable et une variable INetworkConnected. Appelez les méthodes appropriées via chaque référence pour montrer comment le même objet peut être traité différemment selon l’interface avec laquelle vous travaillez.

Vous recevrez trois entrées :

Nom de la marque du téléviseur
Taille de l’écran en pouces
Nom du réseau auquel se connecter

Affichez la sortie dans ce format :

Via SmartTV:
{TurnOn() result}
{Connect(network) result}
Via IControllable:
{TurnOff() result}
Via INetworkConnected:
{Connect(network) result}

Par exemple, si les entrées sont Samsung, 55 et HomeWiFi, la sortie doit être :

Via SmartTV:
Samsung 55-inch TV is now ON
Samsung TV connected to HomeWiFi
Via IControllable:
Samsung 55-inch TV is now OFF
Via INetworkConnected:
Samsung TV connected to HomeWiFi

Remarquez comment le même objet SmartTV peut être accessible via différentes références d’interface. Lorsqu’il est stocké en tant que IControllable, vous pouvez uniquement appeler les méthodes de contrôle. Lorsqu’il est stocké en tant que INetworkConnected, vous pouvez uniquement appeler les méthodes réseau. C’est là toute la puissance de l’implémentation de plusieurs interfaces : une seule classe acquiert plusieurs capacités tout en restant flexible dans son utilisation !

Essayez vous-même

using System;
using SmartHome;

class Program
{
    public static void Main(string[] args)
    {
        // Lire les entrées
        string brand = Console.ReadLine();
        int screenSize = Convert.ToInt32(Console.ReadLine());
        string network = Console.ReadLine();
        
        // TODO: Créer un objet SmartTV avec les valeurs d'entrée
        
        // TODO: Stocker le même objet TV dans trois types de variables différents :
        // 1. Type SmartTV (classe concrète)
        // 2. IControllable type (interface reference)
        // 3. INetworkConnected type (interface reference)
        
        // TODO: Afficher la sortie au format requis :
        // Via SmartTV:
        // - Appeler TurnOn() et Connect(network)
        // Via IControllable:
        // - Appeler TurnOff()
        // Via INetworkConnected:
        // - Appeler Connect(network)
        
    }
}