Interfejsy w Javie: definiowanie kontraktów i implements

Interfejs to kontrakt

Interfejs deklaruje, co klasa potrafi, nie mówiąc, jak. To lista sygnatur metod, które każda implementująca go klasa obiecuje spełnić. Chodzi o rozdzielenie zależności: kod może pracować z typem interfejsu i nie przejmować się tym, jaka konkretna klasa stoi za nim.

interface Shape {
    double area();          // każdy Shape musi podawać pole (area)
    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 oznacza, że Circle musi zdefiniować area i perimeter. Gdy to zrobi, Circle jest Shape i można go przechowywać w zmiennej typu Shape.

Wiele klas, jeden typ

Siła interfejsów widać wtedy, gdy kilka niepowiązanych klas implementuje ten sam interfejs. Kod napisany pod Shape obsługuje je wszystkie:

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();   // działa dla każdego Shape, niezależnie od jego klasy
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Pętla nigdy nie pyta „czy to Circle, czy Rectangle?”. Po prostu wywołuje area() i ufa kontraktowi. Dodanie później klasy Triangle nie wymaga tu żadnej zmiany.

Implementowanie wielu interfejsów

Klasa rozszerza tylko jedną klasę, ale może implementować dowolną liczbę interfejsów. Tak Java bezpiecznie realizuje „wielokrotne dziedziczenie” zachowania:

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();
    }
}

Wypisz interfejsy po przecinku po implements. Klasa musi spełnić je wszystkie.

Metody default i static

Od Javy 8 interfejs może zawierać ciała metod. Metoda default daje klasom implementującym gotową implementację, którą dziedziczą za darmo (i mogą nadpisać):

interface Greeter {
    String name();

    default String greet() {        // wspólna implementacja
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() jest dziedziczone z interfejsu
}

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

Metody default pozwalają interfejsowi ewoluować: można dodać metodę, nie psując żadnej istniejącej implementacji. Metoda static interfejsu działa natomiast jak inne składowe statyczne: to funkcja pomocnicza wywoływana na samym interfejsie, na przykład Comparator.naturalOrder().

Stałe

Pola w interfejsie są niejawnie public static final: to stałe, a nie stan instancji:

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

Interfejsy tradycyjnie nie przechowują stanu poszczególnych obiektów. Brak pól instancji to część tego, co odróżnia je od klas.

Interfejsy funkcyjne

Interfejs z dokładnie jedną metodą abstrakcyjną to interfejs funkcyjny i możesz go zaimplementować wyrażeniem lambda zamiast całej klasy:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // lambda implementuje jedyną metodę
        System.out.println(doubler.apply(21));
    }
}

To podstawa lambd w Javie i typów z java.util.function (Function, Predicate, Supplier i pokrewnych). Adnotacja @FunctionalInterface jawnie pokazuje intencję i pozwala kompilatorowi pilnować zasady jednej metody.

Interfejs a klasa abstrakcyjna

Oba pozwalają programować pod abstrakcję, więc kiedy wybrać które?

• Interfejs: zdolność, którą mogą współdzielić niepowiązane klasy. Bird i Airplane mogą być jednocześnie Flyable. Klasa może implementować wiele interfejsów. Brak stanu instancji.
• Klasa abstrakcyjna: wspólny stan i kod blisko spokrewnionych klas. Cat i Dog rozszerzają Animal, dziedzicząc wspólne pola i częściowo zaimplementowane metody. Klasa rozszerza tylko jedną.

Popularny wzorzec łączy oba podejścia: interfejs definiuje kontrakt, a klasa abstrakcyjna implementuje powtarzalne części, więc konkretne podklasy uzupełniają tylko szczegóły.

Dalej: klasy abstrakcyjne

Interfejsy definiują zachowanie bez stanu. Klasy abstrakcyjne leżą pomiędzy interfejsami a pełnymi klasami: mogą deklarować niezaimplementowane metody i mieć pola oraz konstruktory. O tym jest następna strona.