Interfacce in Java: definire contratti e implements

Un'interfaccia è un contratto

Un'interfaccia dichiara cosa può fare una classe senza dire come. È un elenco di firme di metodi che ogni classe che la implementa promette di rispettare. Lo scopo è il disaccoppiamento: il codice può lavorare con il tipo dell'interfaccia senza preoccuparsi di quale classe concreta ci sia dietro.

interface Shape {
    double area();          // ogni Shape deve fornire un'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 significa che Circle deve definire area e perimeter. Una volta fatto, un Circle è una Shape e può essere memorizzato in una variabile di tipo Shape.

Tante classi, un solo tipo

La potenza si vede quando più classi non collegate tra loro implementano la stessa interfaccia. Il codice scritto per Shape le gestisce tutte:

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();   // funziona per ogni Shape, qualunque sia la sua classe
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Il ciclo non chiede mai "questo è un Circle o un Rectangle?": chiama semplicemente area() e si fida del contratto. Aggiungere un Triangle in seguito non richiede alcuna modifica qui.

Implementare più interfacce

Una classe estende una sola classe, ma può implementare un numero qualsiasi di interfacce: è così che Java ottiene in modo sicuro l'"ereditarietà multipla" del comportamento:

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

Elenca le interfacce separate da virgole dopo implements. La classe deve soddisfarle tutte.

Metodi default e static

Da Java 8 un'interfaccia può contenere corpi di metodo. Un metodo default dà alle classi che la implementano un'implementazione già pronta che ereditano gratis (e possono ridefinire):

interface Greeter {
    String name();

    default String greet() {        // implementazione condivisa
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() viene ereditato dall'interfaccia
}

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

I metodi default permettono a un'interfaccia di evolversi: si aggiunge un metodo senza rompere tutte le classi che già la implementano. Un metodo static di un'interfaccia, invece, è un'utilità che richiami sull'interfaccia stessa, come Comparator.naturalOrder().

Costanti

I campi di un'interfaccia sono implicitamente public static final: sono costanti, non stato di istanza:

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

Tradizionalmente le interfacce non hanno stato per oggetto; l'assenza di campi di istanza è parte di ciò che le distingue dalle classi.

Interfacce funzionali

Un'interfaccia con esattamente un metodo astratto è un'interfaccia funzionale, e puoi implementarla con una lambda expression invece di un'intera classe:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // la lambda implementa l'unico metodo
        System.out.println(doubler.apply(21));
    }
}

Questa è la base delle lambda di Java e dei tipi di java.util.function (Function, Predicate, Supplier e compagnia). L'annotazione @FunctionalInterface rende esplicita l'intenzione e fa sì che il compilatore imponga la regola del metodo unico.

Interfaccia o classe astratta

Entrambe ti permettono di programmare verso un'astrazione, quindi quando scegliere l'una o l'altra?

• Interfaccia: una capacità che classi non collegate tra loro possono condividere. Un Bird e un Airplane possono essere entrambi Flyable. Una classe può implementarne molte. Nessuno stato di istanza.
• Classe astratta: stato e codice condivisi tra classi strettamente correlate. Un Cat e un Dog estendono entrambi Animal, ereditando campi comuni e metodi parzialmente implementati. Una classe ne estende una sola.

Uno schema comune le combina: un'interfaccia definisce il contratto e una classe astratta implementa le parti ripetitive, così le sottoclassi concrete completano solo i dettagli specifici.

Prossimo argomento: le classi astratte

Le interfacce definiscono comportamento senza stato. Le classi astratte stanno a metà strada tra le interfacce e le classi complete: possono dichiarare metodi non implementati e avere anche campi e costruttori. È l'argomento della pagina successiva.