Méthodes statiques dans les interfaces

1. Introduction

Avant Java 8, une interface n’était qu’un « contrat » : uniquement des méthodes abstraites, aucune implémentation, aucune logique, juste des promesses. Mais à partir de Java 8, les interfaces sont devenues un peu plus « autonomes » : elles peuvent désormais contenir non seulement des méthodes par défaut (default), mais aussi des méthodes statiques.

Les méthodes statiques dans les interfaces sont des méthodes qui appartiennent à l’interface elle‑même, et non à ses implémentations (classes). Elles ne nécessitent pas la création d’un objet et sont appelées directement via le nom de l’interface.

Analogie :
Les méthodes statiques dans les interfaces, c’est comme un pense‑bête affiché au mur du bureau : chaque employé (classe) peut s’y référer, mais ce pense‑bête n’appartient à aucun employé en particulier.

Les méthodes statiques dans les interfaces permettent de regrouper des fonctions d’assistance liées à cette interface, sans encombrer l’espace de noms des classes qui l’implémentent.

Syntaxe des méthodes static dans les interfaces

Les méthodes statiques sont déclarées à l’intérieur d’une interface avec le mot‑clé static. Elles peuvent contenir une implémentation (du code entre accolades) et ne peuvent être appelées que via le nom de l’interface.

Exemple :

public interface MathUtils {
    static int sum(int a, int b) {
        return a + b;
    }

    static double average(int a, int b) {
        return (a + b) / 2.0;
    }
}

Appel d’une méthode static d’interface :

int result = MathUtils.sum(5, 7);        // 12
double avg = MathUtils.average(10, 20);  // 15.0

Attention :
Il est impossible d’appeler une méthode static d’interface via une classe implémentante ou un objet ! Uniquement via le nom de l’interface.

2. En quoi les méthodes static d’une interface diffèrent‑elles des méthodes default ?

Static-méthodes :

• Appartiennent à l’interface elle‑même.
• Ne sont pas héritées par les classes qui l’implémentent.
• Ne peuvent pas être appelées via un objet de classe.
• Ne peuvent pas être redéfinies dans une classe implémentante.
• Ne peuvent être appelées que via le nom de l’interface.

default-méthodes :

• Appartiennent à l’objet (instance) de la classe qui implémente l’interface.
• Peuvent être redéfinies dans la classe implémentante.
• Peuvent être appelées via un objet de la classe implémentante.
• Sont héritées par les classes implémentantes.

En résumé : les méthodes default étendent les capacités de l’objet, tandis que les méthodes static étendent celles de l’interface elle‑même.

Exemple comparatif :

interface Printer {
    default void print(String text) {
        System.out.println("Default: " + text);
    }

    static void info() {
        System.out.println("Printer interface v1.0");
    }
}

class ConsolePrinter implements Printer {}

public class Main {
    public static void main(String[] args) {
        Printer.info(); // Appel de la méthode static via l'interface

        ConsolePrinter cp = new ConsolePrinter();
        cp.print("Hello!"); // Appel de la méthode default via l'objet
        // cp.info(); // Erreur ! Impossible d'appeler une méthode static via un objet
    }
}

3. À quoi servent les méthodes static dans les interfaces ?

Avant l’arrivée des méthodes static dans les interfaces, si vous aviez besoin d’ajouter une fonction utilitaire liée à l’interface, vous deviez créer des classes séparées avec le suffixe Utils ou Helper :

public interface Movable {
    void move(int x, int y);
}

public class MovableUtils {
    public static void resetPosition(Movable m) {
        m.move(0, 0);
    }
}

On peut désormais le faire directement dans l’interface :

public interface Movable {
    void move(int x, int y);

    static void resetPosition(Movable m) {
        m.move(0, 0);
    }
}

Cela rend le code plus logique et cohérent : les méthodes relatives à l’interface vivent maintenant directement en son sein.

Avantages :

• Regrouper les fonctions utilitaires à proximité du contrat de l’interface.
• N’encombrent pas l’espace de noms des classes implémentantes.
• Améliorent la lisibilité et la maintenance du code.

4. Limitations et particularités des méthodes static d’interface

Les méthodes static d’une interface ne sont pas héritées par les classes qui l’implémentent.

On ne peut pas les appeler via un objet de la classe implémentante ni via le nom de la classe. Uniquement via le nom de l’interface !

Les méthodes static dans une interface contiennent toujours une implémentation : elles ne peuvent pas être abstract ni default.

Elles contiennent toujours une implémentation.

Les méthodes static ne peuvent pas accéder aux méthodes ou variables non statiques de l’interface.

Elles peuvent accéder uniquement aux autres membres static de l’interface (par exemple, aux constantes static final).

Les méthodes static d’interface peuvent être privées (Java 9+).

On peut créer des méthodes private static auxiliaires à utiliser à l’intérieur de l’interface.

5. Exemple : méthodes static pour l’interface Movable

Voyons comment ajouter des méthodes static à l’interface Movable. Supposons que nous ayons une interface Movable implémentée par différentes classes (par exemple, des robots, des animaux, des moyens de transport).

Étape 1. Déclarer l’interface avec une méthode static :

public interface Movable {
    void move(int x, int y);

    static void resetPosition(Movable obj) {
        obj.move(0, 0);
    }

    static double distance(int x1, int y1, int x2, int y2) {
        int dx = x2 - x1;
        int dy = y2 - y1;
        return Math.sqrt(dx * dx + dy * dy);
    }
}

Étape 2. Implémenter l’interface dans une classe :

public class Robot implements Movable {
    private int x, y;

    public Robot(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public void move(int x, int y) {
        System.out.println("Le robot se déplace vers le point (" + x + "," + y + ")");
        this.x = x;
        this.y = y;
    }

    public void printPosition() {
        System.out.println("Position actuelle : (" + x + "," + y + ")");
    }
}

Étape 3. Utiliser les méthodes static de l’interface :

public class Main {
    public static void main(String[] args) {
        Robot robby = new Robot(10, 15);
        robby.printPosition();

        // Réinitialisation de la position via une méthode static de l'interface
        Movable.resetPosition(robby);
        robby.printPosition();

        // Calcul de la distance entre deux points via une méthode static de l'interface
        double dist = Movable.distance(0, 0, 10, 15);
        System.out.println("Distance : " + dist);
    }
}

Résultat :

Position actuelle : (10,15)
Le robot se déplace vers le point (0,0)
Position actuelle : (0,0)
Distance : 18.027756377319946

Remarque :
Nous appelons Movable.resetPosition(robby), et non robby.resetPosition(). Les méthodes static sont pratiques pour les opérations qui relèvent logiquement de l’interface, mais pas d’un objet concret.

6. Méthodes private static dans les interfaces

Parfois, une interface a besoin de méthodes auxiliaires uniquement pour un usage interne (par exemple, pour éviter de dupliquer du code dans plusieurs méthodes static ou default). Depuis Java 9, les interfaces prennent en charge les méthodes private static.

Exemple :

public interface Logger {
    static void logInfo(String message) {
        log("INFO", message);
    }
    static void logError(String message) {
        log("ERROR", message);
    }
    private static void log(String level, String message) {
        System.out.println("[" + level + "] " + message);
    }
}

Désormais, log() n’est pas accessible depuis l’extérieur de l’interface, mais il est utilisé à l’intérieur des autres méthodes static.

7. Où trouve‑t‑on des méthodes static dans la bibliothèque standard Java ?

Les méthodes static dans les interfaces sont largement utilisées dans la bibliothèque standard Java, en particulier dans les collections et les interfaces fonctionnelles.

Exemples :

• Comparator.comparing(), Comparator.reverseOrder() — méthodes static de l’interface Comparator.
• Predicate.isEqual() — méthode static de l’interface Predicate.
• List.of(), Set.of(), Map.of() (Java 9+) — méthodes static pour créer des collections immuables.

Exemple avec Comparator :

import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Comparator<String> cmp = Comparator.reverseOrder();
        int res = cmp.compare("a", "b"); // nombre positif, car "a" > "b" en ordre inverse
        System.out.println(res);
    }
}

8. Erreurs typiques avec les méthodes static d’interface

Erreur n°1 : tentative d’appel d’une méthode static via un objet de la classe implémentante.
Cela ne fonctionnera pas ! Une méthode static d’interface s’appelle uniquement via le nom de l’interface, par exemple Movable.resetPosition(obj), et non obj.resetPosition().

Erreur n°2 : tentative de redéfinir une méthode static d’interface dans la classe implémentante.
Les méthodes static ne sont ni héritées ni redéfinies ! Si vous déclarez dans la classe une méthode static portant le même nom, ce sera une méthode totalement différente, sans lien avec l’interface.

Erreur n°3 : oublier que les méthodes static ne peuvent pas accéder aux membres non statiques.
Les méthodes static d’interface ne peuvent utiliser que des membres static (par exemple, des constantes static final) et ne peuvent pas accéder aux méthodes ou variables non statiques.

Erreur n°4 : confusion avec les méthodes default.
Les méthodes default s’appellent via l’objet, les méthodes static — uniquement via le nom de l’interface. Ne les confondez pas !