CodeGym /Kurse /JAVA 25 SELF /Mehrfache Implementierung von Interfaces

Mehrfache Implementierung von Interfaces

JAVA 25 SELF
Level 20, Lektion 2
Verfügbar

1. Einleitung

In Java kann eine Klasse nicht mehrere Oberklassen gleichzeitig erben. Das wurde bewusst so gestaltet, um das „Diamantproblem“ zu vermeiden – eine Situation, in der zwei Elternklassen dieselbe Methode definieren und unklar ist, welche Implementierung verwendet werden soll. Interfaces hingegen kann man beliebig viele implementieren! Warum? Weil ein Interface nur ein Vertrag ist, es enthält keine Implementierung (bis Java 8 – ohne Implementierung; seit Java 8 – sind default- und static-Methoden möglich). Das bedeutet, es gibt keine Verwirrung durch vererbten Code.

Das ähnelt der realen Welt: Sie können gleichzeitig „Fahrer“, „Computerbenutzer“ und „Schwimmer“ sein. Jedes dieser „Interfaces“ beschreibt bestimmte Fähigkeiten, zwingt Sie aber nicht, eine Kopie einer anderen Person zu sein.

Syntax der mehrfachen Implementierung von Interfaces

In Java kann eine Klasse mehrere Interfaces implementieren, indem sie diese nach dem Schlüsselwort implements durch Kommas auflistet. Hier ein grundlegendes Beispiel:

public interface Movable {
    void move(int x, int y);
}

public interface Chargeable {
    void charge();
}

public class Robot implements Movable, Chargeable {
    @Override
    public void move(int x, int y) {
        System.out.println("Der Roboter bewegt sich zum Punkt (" + x + ", " + y + ")");
    }

    @Override
    public void charge() {
      System.out.println("Der Roboter lädt auf.");
    }
}

In diesem Beispiel ist Robot ein echter Allrounder: Er kann sich bewegen und laden. Wie im Leben: Je mehr du kannst, desto häufiger wirst du zu Vorstellungsgesprächen eingeladen!

2. Wozu braucht man das? Praxisbeispiele

Beispiel 1. Unterschiedliche „Rollen“ eines Objekts

Stellen Sie sich vor, Sie entwerfen eine Spielfigur:

  • Sie kann sich bewegen (Movable)
  • Sie kann angreifen (Attackable)
  • Sie kann in eine Datei gespeichert werden (Serializable – ein solches Interface gibt es in der Java-Standardbibliothek)
public interface Attackable {
    void attack();
}

public class Hero implements Movable, Attackable, java.io.Serializable {
    @Override
    public void move(int x, int y) {
        System.out.println("Der Held bewegt sich zu einer neuen Position.");
    }

    @Override
    public void attack() {
        System.out.println("Der Held greift an!");
    }
}

Nun kann Ihre Klasse in ganz verschiedenen Kontexten verwendet werden: Man kann sie an Methoden übergeben, die eines dieser Interfaces verlangen.

Beispiel 2. Kombinieren von Standard-Interfaces

Sehr häufig trifft man in der Java-Standardbibliothek auf die Interfaces Comparable (zum Vergleichen von Objekten) und Serializable (zum Speichern von Objekten in einer Datei oder zum Übertragen über das Netzwerk). Manchmal muss ein Objekt beides sein:

public class Person implements Comparable<Person>, java.io.Serializable {
    private String name;
    private int age;

    public Person(String name, int age) { this.name = name; this.age = age; }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}

Jetzt kann man Person-Objekte sortieren (zum Beispiel in einer Liste) und in eine Datei schreiben.

3. Besonderheiten und Einschränkungen

Eine Implementierung pro Methode

Wenn zwei Interfaces eine Methode mit derselben Signatur definieren, muss man sie nur einmal implementieren. Beispiel:

public interface A {
    void doSomething();
}
public interface B {
    void doSomething();
}
public class MyClass implements A, B {
    @Override
    public void doSomething() {
        System.out.println("Implementierung von doSomething für beide Interfaces.");
    }
}

Java wird sich nicht beschweren – wichtig ist, dass die Signaturen übereinstimmen. Wenn sich die Methoden in der Signatur unterscheiden, gelten sie als verschieden – dann muss jede implementiert werden.

Kein „Diamantproblem“

Im Unterschied zur Mehrfachvererbung von Klassen tritt bei der Implementierung mehrerer Interfaces nicht die Situation auf, dass zwei unterschiedliche Implementierungen derselben Methode geerbt werden. Bis Java 8 gab es in Interfaces überhaupt keine Implementierungen, und seit dem Aufkommen von default-Methoden gilt: Entsteht ein Konflikt, müssen Sie ihn explizit auflösen (mehr dazu in der nächsten Vorlesung).

Kein Zustand

Interfaces können keine normalen Felder enthalten (nur Konstanten – public static final). Daher entsteht keine Verwechslung mit „zwei Elternfeldern gleichen Namens“.

4. Beispiel: mehrere Interfaces in einer Klasse implementieren

Erweitern wir unsere Lernanwendung (zum Beispiel einen Zoo) um neue Möglichkeiten. Nehmen wir an, wir haben Tiere, die sich bewegen und Laute von sich geben können:

public interface Movable {
    void move(int x, int y);
}

public interface Soundable {
    void makeSound();
}

public class Dog implements Movable, Soundable {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    @Override
    public void move(int x, int y) {
        System.out.println(name + " läuft zu (" + x + ", " + y + ")");
    }

    @Override
    public void makeSound() {
        System.out.println(name + " sagt: Wau-wau!");
    }
}

public class Cat implements Movable, Soundable {
    private String name;

    public Cat(String name) {
        this.name = name;
    }

    @Override
    public void move(int x, int y) {
        System.out.println(name + " schleicht zu (" + x + ", " + y + ")");
    }

    @Override
    public void makeSound() {
        System.out.println(name + " sagt: Miau!");
    }
}

Nun können wir eine universelle Methode schreiben, um mit jedem „beweglichen“ oder „tönenden“ Objekt zu arbeiten:

public static void testMovable(Movable m) {
    m.move(10, 20);
}

public static void testSoundable(Soundable s) {
    s.makeSound();
}

public static void main(String[] args) {
    Dog rex = new Dog("Rex");
    Cat minnie = new Cat("Minnie");

    testMovable(rex);       // Rex läuft zu (10, 20)
    testSoundable(minnie);   // Minnie sagt: Miau!
}

Und natürlich gilt: Wenn ein Objekt beide Interfaces implementiert, kann man es überallhin übergeben!

6. Nützliche Details

Was, wenn Interfaces kollidieren?

Manchmal definieren zwei Interfaces Methoden mit derselben Signatur, aber unterschiedlicher Bedeutung. Beispielsweise erwartet das eine Interface, dass die Methode reset() Koordinaten zurücksetzt, während das andere erwartet, dass dieselbe Methode ein Gerät ausschaltet. In diesem Fall ist Vorsicht geboten: Implementieren müssen Sie die Methode trotzdem nur einmal, und sie sollte beide Verhaltensweisen „können“ (oder zumindest eine klare Entscheidung treffen). Solche Situationen sind in der Praxis selten, doch wenn sie auftreten, sollte man das Design überdenken.

Beispiel: eine Sammlung von Objekten verschiedener Interfaces

Angenommen, wir haben eine Liste von Objekten, die unterschiedliche Interfaces implementieren. Wir können sie durchlaufen und die gewünschten Methoden aufrufen:

Movable[] movables = {
    new Dog("Buddy"),
    new Cat("Felix"),
    new Robot()
};

for (Movable m : movables) {
    m.move(0, 0);
}

Analog lässt sich das für jedes Interface machen.

7. Typische Fehler bei der mehrfachen Implementierung von Interfaces

Fehler Nr. 1: Nicht alle Methoden der Interfaces sind implementiert.
Wenn eine Klasse angibt, ein Interface zu implementieren, aber mindestens eine seiner Methoden nicht implementiert, meldet der Compiler sofort einen Fehler. Vergessen Sie keine Methoden, auch wenn sie „überflüssig“ erscheinen.

Fehler Nr. 2: Konfliktierende Methoden mit identischer Signatur.
Wenn zwei Interfaces identische Methoden definieren, müssen sie nur einmal implementiert werden. Haben diese Methoden jedoch unterschiedliche Bedeutungen, kann das zu Verwirrung und Bugs führen. In diesem Fall ist es besser, die Architektur zu überdenken.

Fehler Nr. 3: Versuch, ein Interface in einer Klasse mit extends zu erben.
In einer Klasse verwendet man zur Implementierung eines Interfaces immer implements, nicht extends. Zum Beispiel:

public class MyClass implements A, B { ... } // korrekt
public class MyClass extends A, B { ... }    // Fehler!

Fehler Nr. 4: Versuch, ein Objekt eines Interfaces zu erstellen.
Ein Interface ist ein Vertrag, es kann nicht direkt instanziiert werden:

Movable m = new Movable(); // Compilerfehler

Erstellen kann man nur Objekte von Klassen, die das Interface implementieren.

1
Aufgabe
JAVA 25 SELF, Level 20, Lektion 2
Gesperrt
Digitale Leinwand: Zeichnen und Löschen
Digitale Leinwand: Zeichnen und Löschen
1
Aufgabe
JAVA 25 SELF, Level 20, Lektion 2
Gesperrt
Benutzerprofil: Name und Serialisierbarkeit
Benutzerprofil: Name und Serialisierbarkeit
1
Aufgabe
JAVA 25 SELF, Level 20, Lektion 2
Gesperrt
Universelle Aktion: Ein einziger Knopf für alles
Universelle Aktion: Ein einziger Knopf für alles
1
Aufgabe
JAVA 25 SELF, Level 20, Lektion 2
Gesperrt
Mediacenter: Wiedergabe und Aufnahme
Mediacenter: Wiedergabe und Aufnahme
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION