Java-Interfaces: Verträge definieren und implements

Ein Interface ist ein Vertrag

Ein Interface deklariert, was eine Klasse tun kann, ohne zu sagen, wie. Es ist eine Liste von Methodensignaturen, die jede implementierende Klasse zu erfüllen verspricht. Der Sinn ist die Entkopplung: Code kann mit dem Interface-Typ arbeiten, ohne sich darum zu kümmern, welche konkrete Klasse dahintersteckt.

interface Shape {
    double area();          // jede Shape muss eine area bereitstellen
    double perimeter();
}

class Circle implements Shape {
    private final double radius;

    Circle(double radius) { this.radius = radius; }

    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.printf("area %.2f, perimeter %.2f%n", s.area(), s.perimeter());
    }
}

Circle implements Shape bedeutet, dass Circle area und perimeter definieren muss. Sobald sie das tut, ist ein Circle eine Shape und kann in einer Shape-Variablen gespeichert werden.

Viele Klassen, ein Typ

Die Stärke zeigt sich, wenn mehrere nicht verwandte Klassen dasselbe Interface implementieren. Code, der gegen Shape geschrieben ist, verarbeitet sie alle:

import java.util.List;

interface Shape {
    double area();
}

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    public double area() { return Math.PI * r * r; }
}

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Rectangle(2, 3), new Circle(2));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // funktioniert für jede Shape, egal welche Klasse
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Die Schleife fragt nie „ist das ein Circle oder ein Rectangle?" - sie ruft einfach area() auf und vertraut dem Vertrag. Ein Triangle später hinzuzufügen erfordert hier keine Änderung.

Mehrere Interfaces implementieren

Eine Klasse erweitert nur eine Klasse, kann aber beliebig viele Interfaces implementieren - so realisiert Java die „Mehrfachvererbung" von Verhalten auf sichere Weise:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }

class Sprite implements Drawable, Resizable {
    private double scale = 1.0;

    public void draw() { System.out.println("drawing at scale " + scale); }
    public void resize(double factor) { scale *= factor; }
}

public class Main {
    public static void main(String[] args) {
        Sprite s = new Sprite();
        s.resize(2.0);
        s.draw();
    }
}

Liste die Interfaces durch Kommas getrennt nach implements auf. Die Klasse muss alle erfüllen.

default- und static-Methoden

Seit Java 8 kann ein Interface Methodenrümpfe enthalten. Eine default-Methode gibt implementierenden Klassen eine fertige Implementierung, die sie kostenlos erben (und überschreiben können):

interface Greeter {
    String name();

    default String greet() {        // gemeinsame Implementierung
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() wird vom Interface geerbt
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new English().greet());
    }
}

default-Methoden ermöglichen es einem Interface, sich weiterzuentwickeln - eine Methode hinzuzufügen, ohne jeden bestehenden Implementierer zu brechen. Eine static-Interface-Methode hingegen ist ein Hilfsmittel, das du auf dem Interface selbst aufrufst, wie Comparator.naturalOrder().

Konstanten

Felder in einem Interface sind implizit public static final - es sind Konstanten, kein Instanzzustand:

interface Physics {
    double GRAVITY = 9.81;   // automatically public static final
}

Interfaces halten traditionell keinen objektbezogenen Zustand; das Fehlen von Instanzfeldern ist Teil dessen, was sie von Klassen unterscheidet.

Funktionale Interfaces

Ein Interface mit genau einer abstrakten Methode ist ein funktionales Interface, und du kannst es mit einem Lambda-Ausdruck statt mit einer ganzen Klasse implementieren:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // das Lambda implementiert die einzige Methode
        System.out.println(doubler.apply(21));
    }
}

Dies ist die Grundlage von Javas Lambdas und der Typen aus java.util.function (Function, Predicate, Supplier und Verwandte). Die Annotation @FunctionalInterface macht die Absicht explizit und lässt den Compiler die Regel der einzigen Methode durchsetzen.

Interface gegenüber abstrakter Klasse

Beide lassen dich gegen eine Abstraktion programmieren - wann wählst du also was?

• Interface - eine Fähigkeit, die nicht verwandte Klassen teilen können. Ein Bird und ein Airplane können beide Flyable sein. Eine Klasse kann viele implementieren. Kein Instanzzustand.
• Abstrakte Klasse - gemeinsamer Zustand und Code zwischen eng verwandten Klassen. Eine Cat und ein Dog erweitern beide Animal und erben gemeinsame Felder und teilweise implementierte Methoden. Eine Klasse erweitert nur eine.

Ein verbreitetes Muster kombiniert beide: ein Interface definiert den Vertrag, und eine abstrakte Klasse implementiert die immer wiederkehrenden Teile, sodass konkrete Unterklassen nur noch die Besonderheiten ausfüllen.

Als Nächstes: Abstrakte Klassen

Interfaces definieren Verhalten ohne Zustand. Abstrakte Klassen liegen zwischen Interfaces und vollständigen Klassen - sie können nicht implementierte Methoden deklarieren und Felder und Konstruktoren tragen. Das ist das Thema der nächsten Seite.