Interfacce multiple

Fa parte della sezione Programmazione orientata agli oggetti del percorso C# di Coddy. Lezione 27 di 70.

Una classe può ereditare da una sola classe base, ma può implementare tutte le interfacce necessarie. Questo è uno dei principali vantaggi delle interfacce rispetto alle classi astratte: permettono a una classe di adottare più comportamenti.

Per implementare più interfacce, elencale semplicemente dopo i due punti, separate da virgole:

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 deve implementare tutti i membri di entrambe le interfacce. Questo rappresenta in modo naturale gli scenari del mondo reale: un’anatra può davvero sia volare sia nuotare, quindi è sensato che rispetti entrambi i contratti.

Quando combini l'ereditarietà con più interfacce, la classe base deve venire per prima:

public class Duck : Bird, IFlyable, ISwimmable
{
    // Eredita da Bird e implementa entrambe le interfacce
}

Questa flessibilità ti consente di combinare comportamenti provenienti da più fonti. Un Robot potrebbe implementare IMovable, IChargeable e ISpeakable. Ogni interfaccia rappresenta una singola capacità e la tua classe può combinare esattamente ciò di cui ha bisogno.

Sfida

Facile

Costruiamo un sistema di dispositivi per la casa intelligente che dimostri come una singola classe possa implementare più interfacce per acquisire capacità diverse. Creerai dispositivi che possono essere controllati e che dispongono di funzionalità di gestione dell'alimentazione.

Organizzerai il codice in quattro file:

IControllable.cs: definisci un'interfaccia chiamata IControllable nello spazio dei nomi SmartHome. Questa interfaccia rappresenta i dispositivi che possono essere accesi e spenti. Dovrebbe dichiarare due metodi: TurnOn() e TurnOff(), entrambi con un valore restituito di tipo stringa.
INetworkConnected.cs: definisci un'interfaccia chiamata INetworkConnected nello spazio dei nomi SmartHome. Questa interfaccia rappresenta i dispositivi che possono connettersi a una rete. Dovrebbe dichiarare un metodo Connect(string network) che restituisce una stringa.
SmartTV.cs: definisci una classe SmartTV nello spazio dei nomi SmartHome che implementa sia IControllable sia INetworkConnected. La TV dovrebbe avere una proprietà Brand (stringa) e una proprietà ScreenSize (int, che rappresenta i pollici). Crea un costruttore che accetti entrambi i valori. Implementa tutti i metodi dell'interfaccia:
- TurnOn() restituisce "{Brand} {ScreenSize}-inch TV is now ON"
- TurnOff() restituisce "{Brand} {ScreenSize}-inch TV is now OFF"
- Connect(string network) restituisce "{Brand} TV connected to {network}"
Program.cs: nel file principale, crea una SmartTV usando i valori di input. Mostra la flessibilità delle interfacce multiple memorizzando lo stesso oggetto TV in variabili di tre tipi diversi: il tipo concreto SmartTV, una variabile IControllable e una variabile INetworkConnected. Chiama i metodi appropriati tramite ciascun riferimento per mostrare come lo stesso oggetto possa essere usato in modo diverso a seconda dell'interfaccia con cui stai lavorando.

Riceverai tre input:

Nome della marca della TV
Dimensioni dello schermo in pollici
Nome della rete a cui connettersi

Stampa l'output in questo formato:

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

Ad esempio, se gli input sono Samsung, 55 e HomeWiFi, l'output dovrebbe essere:

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

Nota come lo stesso oggetto SmartTV possa essere usato tramite riferimenti a interfacce diverse. Quando è memorizzato come IControllable, puoi chiamare solo i metodi di controllo. Quando è memorizzato come INetworkConnected, puoi chiamare solo i metodi di rete. Questo è il vantaggio di implementare più interfacce: una classe acquisisce capacità multiple, pur rimanendo flessibile nelle modalità d'uso!

Provalo tu

using System;
using SmartHome;

class Program
{
    public static void Main(string[] args)
    {
        // Lee las entradas
        string brand = Console.ReadLine();
        int screenSize = Convert.ToInt32(Console.ReadLine());
        string network = Console.ReadLine();
        
        // TODO: Crea un objeto SmartTV con los valores de entrada
        
        // TODO: Guarda el mismo objeto TV en tres tipos de variables diferentes:
        // 1. Tipo SmartTV (clase concreta)
        // 2. Tipo IControllable (referencia de interfaz)
        // 3. Tipo INetworkConnected (referencia de interfaz)
        
        // TODO: Imprime la salida en el formato requerido:
        // Via SmartTV:
        // - Llama a TurnOn() y Connect(network)
        // Via IControllable:
        // - Llama a TurnOff()
        // Via INetworkConnected:
        // - Llama a Connect(network)
        
    }
}