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.
GO TO FULL VERSION