Mehrere Interfaces

Teil des Abschnitts Objektorientierte Programmierung der C#-Journey von Coddy. Lektion 27 von 70.

Während eine Klasse nur von einer Basisklasse erben kann, kann sie so viele Schnittstellen implementieren, wie erforderlich sind. Dies ist einer der wesentlichen Vorteile, die Schnittstellen gegenüber abstrakten Klassen haben – sie ermöglichen es einer Klasse, mehrere Verhaltensweisen zu übernehmen.

Um mehrere Schnittstellen zu implementieren, liste sie einfach nach dem Doppelpunkt auf, durch Kommas getrennt:

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");
    }
}

Die Klasse Duck muss alle Member aus beiden Schnittstellen implementieren. Dies bildet Szenarien aus der realen Welt auf natürliche Weise ab – eine Ente kann tatsächlich sowohl fliegen als auch schwimmen, daher ist es sinnvoll, dass sie beide Verträge erfüllt.

Beim Kombinieren von Vererbung mit mehreren Schnittstellen muss die Basisklasse zuerst kommen:

public class Duck : Bird, IFlyable, ISwimmable
{
    // Erbt von Bird, implementiert beide Interfaces
}

Diese Flexibilität ermöglicht es dir, Verhaltensweisen aus mehreren Quellen zusammenzustellen. Ein Robot könnte IMovable, IChargeable und ISpeakable implementieren. Jedes Interface steht für eine einzelne Fähigkeit, und deine Klasse kann genau das kombinieren, was sie benötigt.

Aufgabe

Einfach

Erstellen wir ein Smart-Home-Gerätesystem, das demonstriert, wie eine einzelne Klasse mehrere Schnittstellen implementieren kann, um unterschiedliche Fähigkeiten zu erhalten. Du wirst Geräte erstellen, die sowohl steuerbar sind als auch Funktionen zur Energieverwaltung besitzen können.

Du wirst deinen Code auf vier Dateien verteilen:

IControllable.cs: Definiere eine Schnittstelle namens IControllable im Namespace SmartHome. Diese Schnittstelle repräsentiert Geräte, die ein- und ausgeschaltet werden können. Sie soll zwei Methoden deklarieren: TurnOn() und TurnOff(), die beide einen String zurückgeben.
INetworkConnected.cs: Definiere eine Schnittstelle namens INetworkConnected im Namespace SmartHome. Diese Schnittstelle repräsentiert Geräte, die eine Verbindung zu einem Netzwerk herstellen können. Sie soll eine Methode Connect(string network) deklarieren, die einen String zurückgibt.
SmartTV.cs: Definiere eine Klasse SmartTV im Namespace SmartHome, die sowohl IControllable als auch INetworkConnected implementiert. Der Fernseher soll über eine Eigenschaft Brand (string) und eine Eigenschaft ScreenSize (int, die die Bildschirmgröße in Zoll darstellt) verfügen. Erstelle einen Konstruktor, der beide Werte entgegennimmt. Implementiere alle Schnittstellenmethoden:
- TurnOn() gibt "{Brand} {ScreenSize}-inch TV is now ON" zurück
- TurnOff() gibt "{Brand} {ScreenSize}-inch TV is now OFF" zurück
- Connect(string network) gibt "{Brand} TV connected to {network}" zurück
Program.cs: Erstelle in deiner Hauptdatei mithilfe von Eingabewerten ein SmartTV-Objekt. Zeige die Flexibilität mehrerer Schnittstellen, indem du dasselbe TV-Objekt in drei verschiedenen Variablentypen speicherst: im konkreten Typ SmartTV, in einer IControllable-Variablen und in einer INetworkConnected-Variablen. Rufe über jede Referenz die passenden Methoden auf, um zu zeigen, wie dasselbe Objekt je nach verwendeter Schnittstelle unterschiedlich behandelt werden kann.

Du erhältst drei Eingaben:

Name der TV-Marke
Bildschirmgröße in Zoll
Name des Netzwerks, mit dem eine Verbindung hergestellt werden soll

Gib die Ausgabe in diesem Format aus:

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

Wenn die Eingaben beispielsweise Samsung, 55 und HomeWiFi lauten, sollte die Ausgabe folgendermaßen aussehen:

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

Beachte, wie auf dasselbe SmartTV-Objekt über verschiedene Schnittstellenreferenzen zugegriffen werden kann. Wenn es als IControllable gespeichert wird, kannst du nur Steuermethoden aufrufen. Wenn es als INetworkConnected gespeichert wird, kannst du nur Netzwerkmethoden aufrufen. Das ist die Stärke der Implementierung mehrerer Schnittstellen – eine Klasse erhält mehrere Fähigkeiten und bleibt gleichzeitig flexibel in ihrer Verwendung!

Probier es selbst

using System;
using SmartHome;

class Program
{
    public static void Main(string[] args)
    {
        // Eingaben lesen
        string brand = Console.ReadLine();
        int screenSize = Convert.ToInt32(Console.ReadLine());
        string network = Console.ReadLine();
        
        // TODO: Erstelle ein SmartTV-Objekt mit den Eingabewerten
        
        // TODO: Speichere dasselbe TV-Objekt in drei verschiedenen Variablentypen:
        // 1. SmartTV-Typ (konkrete Klasse)
        // 2. IControllable type (interface reference)
        // 3. INetworkConnected type (interface reference)
        
        // TODO: Gib die Ausgabe im erforderlichen Format aus:
        // Via SmartTV:
        // - Rufe TurnOn() und Connect(network) auf
        // Via IControllable:
        // - Rufe TurnOff() auf
        // Via INetworkConnected:
        // - Rufe Connect(network) auf
        
    }
}