Einführung in Interfaces

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 34 von 87.

Du hast gesehen, wie abstrakte Klassen Verträge definieren, die Unterklassen befolgen müssen. Aber was ist, wenn du möchtest, dass eine Klasse mehreren Verträgen folgt? Java erlaubt es einer Klasse nicht, mehrere Klassen zu erweitern, aber es löst dieses Problem mit Schnittstellen.

Eine Schnittstelle ist ein Vertrag, der festlegt, was eine Klasse tun kann, ohne anzugeben, wie sie es tut. Im Gegensatz zu abstrakten Klassen enthalten Schnittstellen (standardmäßig) nur Methodensignaturen, ohne Implementierung:

public interface Drawable {
    void draw();
}

public interface Resizable {
    void resize(int width, int height);
}

Betrachte eine Schnittstelle als ein Versprechen. Wenn eine Klasse eine Schnittstelle implementiert, verspricht sie, Implementierungen für alle in dieser Schnittstelle deklarierten Methoden bereitzustellen. Die Schnittstelle definiert die Fähigkeit, und die Klasse stellt das Verhalten bereit.

Interfaces werden mit dem Schlüsselwort interface statt mit class deklariert. Alle Methoden in einem Interface sind implizit public und abstract, daher musst du diese Schlüsselwörter nicht schreiben:

public interface Playable {
    void play();    // implizit public abstract
    void pause();
    void stop();
}

Interfaces können auch Konstanten deklarieren, die implizit public static final sind:

public interface GameConstants {
    int MAX_PLAYERS = 4;  // implizit public static final
}

In der nächsten Lektion lernst du, wie Klassen mithilfe des Schlüsselworts implements Schnittstellen implementieren.

Aufgabe

Einfach

Erstellen wir ein Gerätesteuerungssystem, indem wir Schnittstellen definieren, die beschreiben, was verschiedene Geräte tun können. Diese Aufgabe konzentriert sich auf das Erstellen von Schnittstellen: den Verträgen, die Fähigkeiten definieren, ohne festzulegen, wie sie funktionieren.

Du wirst deinen Code auf drei Dateien verteilen:

Switchable.java: Erstelle eine Schnittstelle, die definiert, was es bedeutet, dass ein Gerät schaltbar ist. Jedes schaltbare Gerät sollte ein- und ausgeschaltet werden können. Deklariere zwei Methoden: turnOn() und turnOff(). Denke daran: Schnittstellenmethoden sind implizit public und abstract, daher benötigst du nur die Methodensignaturen.
Adjustable.java: Erstelle eine weitere Schnittstelle, die definiert, was es bedeutet, dass ein Gerät einstellbar ist. Ein einstellbares Gerät sollte in der Lage sein, seinen Pegel festzulegen. Deklariere eine Methode setLevel(int level). Füge außerdem eine Konstante MAX_LEVEL mit dem Wert 100 hinzu. Denke daran, dass Konstanten in Schnittstellen implizit public static final sind.
Main.java: Zeige durch das Ausgeben von Informationen über deine Schnittstellen, dass sie ordnungsgemäß definiert sind. Du erhältst eine Eingabe: einen Pegelwert (int). Gib die folgenden drei Zeilen aus:
- Switchable methods: turnOn, turnOff
- Adjustable methods: setLevel
- Max level constant: [MAX_LEVEL value] (greife auf die Konstante aus der Schnittstelle Adjustable zu)
Gib anschließend aus: Setting level to: [input level]

Du erhältst eine Eingabe: einen Pegelwert (int).

Diese Aufgabe konzentriert sich ausschließlich auf das Definieren von Schnittstellen: den Bauplänen, die Fähigkeiten beschreiben. In der nächsten Lektion lernst du, wie Klassen diese Schnittstellen tatsächlich implementieren, um das konkrete Verhalten bereitzustellen!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int level = scanner.nextInt();
        
        // TODO: Informationen über die Interfaces ausgeben
        // Print: "Switchable methods: turnOn, turnOff"
        // Print: "Adjustable methods: setLevel"
        // Print: "Max level constant: " followed by Adjustable.MAX_LEVEL
        // Print: "Setting level to: " followed by the input level
        
    }
}