1. Was ist ein Interface?
Wenn eine abstrakte Klasse ein Bauplan für ein Haus ist, dann ist ein Interface eher ein Vertrag oder „Kontrakt“ zur Erbringung bestimmter Leistungen. Zum Beispiel: Wenn Sie einen Klempner rufen, erwarten Sie, dass er „den Wasserhahn reparieren“ und „ein Leck beheben“ kann. Wie er das macht – ist Ihnen egal, Hauptsache, das Ergebnis stimmt. In Java ist ein Interface genau ein solcher Vertrag: Es sagt, welche Methoden implementiert werden müssen, aber nicht, wie.
Kurz und bündig:
Ein Interface ist ein spezieller Typ in Java, der eine Menge von Methoden definiert, die Klassen, die sich auf dieses Interface „einschreiben“, implementieren müssen.
- Ein Interface beschreibt nur „was zu tun ist“, aber nicht „wie es zu tun ist“.
- Bis Java 8 enthielten Interfaces keine Implementierungen von Methoden.
- Ein Interface ist ein reiner Vertrag: Wenn eine Klasse ein Interface implementiert, muss sie alle dessen Methoden implementieren.
Warum ist das praktisch?
- Man kann einer Klasse mehrere Interfaces „anhängen“ – ihr also mehrere „Rollen“ geben.
- Ermöglicht flexible und erweiterbare Architekturen, in denen Klassen unterschiedliche Fähigkeiten implementieren können.
- Interfaces werden in der Java-Standardbibliothek breit eingesetzt (z. B. Comparable, Serializable, Runnable u. a.).
2. Syntax der Interface-Deklaration
Ein Interface in Java zu deklarieren ist ganz einfach. Dafür wird das Schlüsselwort interface verwendet. Bis Java 8 galten Methoden eines Interface standardmäßig als public abstract, auch wenn das nicht explizit angegeben war. Das bedeutet: Die Methode muss in der Klasse implementiert werden, die das Interface implementiert.
Beispiel eines Interface
public interface Movable {
void move(int x, int y);
}
- Hier deklarieren wir das Interface Movable (sinngemäß: „beweglich“ bzw. „kann sich bewegen“).
- Darin ist die Methode move(int x, int y) deklariert. Es gibt keinen Methodenkörper – nur die Signatur. Das ist der „Vertrag“: „Wenn du Movable implementierst, dann implementiere move.“
Besonderheiten der Syntax
- Methoden in einem Interface haben keinen Körper (bis Java 8).
- Alle Methoden eines Interface sind standardmäßig public abstract (muss nicht explizit geschrieben werden).
- Ein Interface darf nur Konstanten enthalten (public static final), jedoch keine normalen Felder.
Beispiel mit einer Konstante
public interface Constants {
int MAX_SPEED = 100; // public static final standardmäßig
}
3. Unterschied zwischen Interface und Klasse
Ein Interface ist keine Klasse! Schauen wir uns die Unterschiede an.
| Klasse (einschließlich abstrakter) | Interface |
|---|---|
| Kann Felder enthalten (Zustand) | Kann keine Felder enthalten (nur Konstanten) |
| Kann Implementierungen von Methoden enthalten | Bis Java 8 konnten Interfaces keine Implementierungen enthalten, nur Signaturen |
| Kann über new erzeugt werden (wenn nicht abstrakt) | Kann nicht direkt erzeugt werden |
| Nur einfache Vererbung (extends) | Eine Klasse kann mehrere Interfaces implementieren (implements) |
| Wird verwendet für „was es ist“ | Wird verwendet für „was es kann“ |
Eine Klasse implementiert ein Interface mit implements
public class Robot implements Movable {
@Override
public void move(int x, int y) {
System.out.println("Der Roboter bewegt sich zum Punkt (" + x + ", " + y + ")");
}
}
- Die Klasse Robot implementiert das Interface Movable.
- Das Schlüsselwort implements bedeutet „implementiert“.
- Alle Methoden des Interface müssen implementiert werden (sonst gibt es einen Kompilierungsfehler).
- Vergessen Sie die Annotation @Override nicht – sie ist nicht zwingend, hilft aber dem Compiler und Ihnen, Fehler zu vermeiden.
4. Beispiel für die Verwendung eines Interface
Schreiben wir ein einfaches Beispiel, um zu sehen, wie das in der Praxis funktioniert. Stellen wir uns vor, wir haben das Interface Movable und möchten, dass verschiedene Klassen sich „bewegen“ können: Roboter, Auto, Tier …
Schritt 1. Interface deklarieren
public interface Movable {
void move(int x, int y);
}
Schritt 2. Interface in einer Klasse implementieren
public class Robot implements Movable {
@Override
public void move(int x, int y) {
System.out.println("Der Roboter bewegt sich zum Punkt (" + x + ", " + y + ")");
}
}
Schritt 3. Interface verwenden
public class Main {
public static void main(String[] args) {
Movable m = new Robot(); // Variable vom Interface-Typ!
m.move(10, 20); // Ausgabe: Der Roboter bewegt sich zum Punkt (10, 20)
}
}
Beachten Sie
- Wir können eine Variable vom Interface-Typ (Movable m) deklarieren und ihr ein Objekt einer Klasse zuweisen, die dieses Interface implementiert (new Robot()).
- So lässt sich allgemeiner Code schreiben, der mit jedem „beweglichen“ Objekt funktioniert, ohne zu wissen, um welche Klasse es sich tatsächlich handelt.
Kompilierungsfehler, wenn die Methode nicht implementiert wird
Error: Class 'Robot' must either be declared abstract or implement abstract method 'move(int, int)' in 'Movable'
Das ist die Stärke von Interfaces – sie garantieren, dass alle implementierenden Klassen die benötigten Methoden besitzen.
5. Interfaces in der Java-Standardbibliothek
Interfaces sind keineswegs nur ein „Schulthema“. Sie werden in der gesamten Java-Standardbibliothek intensiv verwendet. Hier einige Beispiele:
- Comparable<T> – Interface zum Vergleichen von Objekten (z. B. beim Sortieren).
- Runnable – Interface zum Starten eines Threads.
- Serializable – Marker-Interface, das angibt, dass ein Objekt serialisiert werden kann.
- List, Set, Map – Interfaces der Collections.
Beispiel: Comparable
public class Person implements Comparable<Person> {
String name;
int age;
// Konstruktor und weitere Methoden ...
@Override
public int compareTo(Person other) {
return this.age - other.age;
}
}
Nun lassen sich Objekte von Person sortieren, weil sie das Interface Comparable implementieren.
6. Visuelles Schema: Wie ein Interface funktioniert
+-------------------+ +-------------------+
| interface | | class |
| Movable |<--------| Robot |
|-------------------| |-------------------|
| +move(int, int) | | +move(int, int) |
+-------------------+ +-------------------+
- Der Pfeil zeigt, dass die Klasse Robot das Interface Movable implementiert.
- Das Interface definiert nur „was vorhanden sein muss“, die Klasse – „wie es funktioniert“.
Analogie aus dem Alltag
Ein Interface in Java ist wie ein Führerschein. Wenn Sie einen Führerschein haben (Sie implementieren das Interface „Fahrer“), bedeutet das, dass Sie ein Auto fahren können. Wie genau Sie das tun, ist Detail: Manche fahren vorsichtig, manche schnell – Hauptsache, Sie haben zugesichert, dass Sie es können.
7. Praxisbeispiel: Wir bauen unsere Anwendung aus
public interface Movable {
void move(int x, int y);
}
public class Animal implements Movable {
protected String name;
public Animal(String name) {
this.name = name;
}
@Override
public void move(int x, int y) {
System.out.println(name + " bewegt sich zum Punkt (" + x + ", " + y + ")");
}
}
public class Robot implements Movable {
private String model;
public Robot(String model) {
this.model = model;
}
@Override
public void move(int x, int y) {
System.out.println("Roboter " + model + " fährt zu den Koordinaten (" + x + ", " + y + ")");
}
}
public class Main {
public static void main(String[] args) {
Movable[] movables = {
new Animal("Buddy"),
new Robot("R2D2")
};
for (Movable m : movables) {
m.move(5, 10);
}
}
}
Ergebnis:
Buddy bewegt sich zum Punkt (5, 10)
Roboter R2D2 fährt zu den Koordinaten (5, 10)
Wir haben ein Array von Objekten des Typs Movable erstellt. Es kann beliebige Objekte enthalten, die dieses Interface implementieren! Der Code in der Schleife weiß nicht, was genau vor ihm steht – Tier oder Roboter –, aber er weiß, dass jedes von ihnen move beherrscht.
8. Typische Fehler im Umgang mit Interfaces
Fehler Nr. 1: Versuch, ein Interface direkt zu instanziieren. Ein Interface ist ein Vertrag und kein konkretes Objekt. Man kann nicht new Movable() schreiben – das führt zu einem Kompilierungsfehler. Erstellen Sie Objekte von Klassen, die das Interface implementieren.
Fehler Nr. 2: Nicht alle Methoden des Interface sind implementiert. Wenn eine Klasse ein Interface implementiert, aber nicht alle dessen Methoden implementiert, meldet der Compiler einen Fehler: „Class must either be declared abstract or implement abstract method ...“. Wenn Sie nicht alle Methoden implementieren möchten – deklarieren Sie die Klasse als abstract.
Fehler Nr. 3: Zugriffsmodifikatoren vergessen. Methoden eines Interface sind immer public (auch wenn es nicht explizit dasteht). In der implementierenden Klasse darf der Sichtbarkeitsgrad nicht verringert werden, daher muss die Methode ebenfalls public sein.
Fehler Nr. 4: Versuch, normale Felder zu einem Interface hinzuzufügen. In einem Interface können nur Konstanten deklariert werden (public static final). Normale (nicht statische) Felder sind nicht erlaubt.
GO TO FULL VERSION