Les interfaces en Java : définir des contrats et implements

Une interface est un contrat

Une interface déclare *ce qu'*une classe peut faire sans dire comment. C'est une liste de signatures de méthodes que toute classe qui l'implémente s'engage à respecter. L'enjeu, c'est le découplage : le code peut travailler avec le type de l'interface sans se soucier de la classe concrète qui se trouve derrière.

interface Shape {
    double area();          // toute Shape doit fournir une 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 signifie que Circle doit définir area et perimeter. Une fois que c'est fait, un Circle est une Shape et peut être stocké dans une variable de type Shape.

Plusieurs classes, un seul type

La puissance apparaît lorsque plusieurs classes sans lien entre elles implémentent la même interface. Le code écrit pour Shape les gère toutes :

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();   // fonctionne pour toute Shape, quelle que soit sa classe
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

La boucle ne demande jamais « est-ce un Circle ou un Rectangle ? » - elle appelle simplement area() et fait confiance au contrat. Ajouter un Triangle plus tard ne nécessite aucune modification ici.

Implémenter plusieurs interfaces

Une classe n'étend qu'une seule classe, mais elle peut implémenter un nombre quelconque d'interfaces - c'est ainsi que Java réalise en toute sécurité l'« héritage multiple » de comportement :

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

Énumérez les interfaces séparées par des virgules après implements. La classe doit toutes les satisfaire.

Méthodes default et static

Depuis Java 8, une interface peut contenir des corps de méthode. Une méthode default donne aux classes qui l'implémentent une implémentation toute prête qu'elles héritent gratuitement (et peuvent redéfinir) :

interface Greeter {
    String name();

    default String greet() {        // implémentation partagée
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() est hérité de l'interface
}

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

Les méthodes default permettent à une interface d'évoluer - ajouter une méthode sans casser tous les implémenteurs existants. Une méthode d'interface static, en revanche, est un utilitaire que vous appelez sur l'interface elle-même, comme Comparator.naturalOrder().

Constantes

Les champs d'une interface sont implicitement public static final - ce sont des constantes, pas un état d'instance :

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

Les interfaces ne conservent traditionnellement aucun état par objet ; l'absence de champs d'instance fait partie de ce qui les distingue des classes.

Interfaces fonctionnelles

Une interface possédant exactement une méthode abstraite est une interface fonctionnelle, et vous pouvez l'implémenter avec une expression lambda plutôt qu'avec une classe entière :

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // le lambda implémente l'unique méthode
        System.out.println(doubler.apply(21));
    }
}

C'est le fondement des lambdas de Java et des types de java.util.function (Function, Predicate, Supplier et consorts). L'annotation @FunctionalInterface rend l'intention explicite et permet au compilateur d'imposer la règle de la méthode unique.

Interface contre classe abstraite

Les deux vous permettent de programmer face à une abstraction, alors quand choisir l'une ou l'autre ?

• Interface - une capacité que des classes sans lien entre elles peuvent partager. Un Bird et un Airplane peuvent tous deux être Flyable. Une classe peut en implémenter plusieurs. Pas d'état d'instance.
• Classe abstraite - un état et du code partagés entre des classes étroitement liées. Un Cat et un Dog étendent tous deux Animal, héritant de champs communs et de méthodes partiellement implémentées. Une classe n'en étend qu'une seule.

Un schéma courant combine les deux : une interface définit le contrat, et une classe abstraite implémente les parties répétitives, de sorte que les sous-classes concrètes ne renseignent que les détails spécifiques.

Suite : les classes abstraites

Les interfaces définissent un comportement sans état. Les classes abstraites se situent entre les interfaces et les classes complètes - elles peuvent déclarer des méthodes non implémentées et porter des champs et des constructeurs. C'est le sujet de la page suivante.