Accueil / Language / Méthodes statiques dans les interfaces
Language Débutant

Méthodes statiques dans les interfaces

Ajoutez des méthodes utilitaires statiques directement aux interfaces au lieu de classes utilitaires séparées.

Comparaison de Code
✕ Java 7 
// Separate utility class needed
public class ValidatorUtils {
    public static boolean isBlank(
        String s) {
        return s == null ||
               s.trim().isEmpty();
    }
}

// Usage
if (ValidatorUtils.isBlank(input)) { ... }
✓ Java 8+ 
public interface Validator {
    boolean validate(String s);

    static boolean isBlank(String s) {
        return s == null ||
               s.trim().isEmpty();
    }
}

// Usage
if (Validator.isBlank(input)) { ... }
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
📦

Meilleure organisation

Gardez les utilitaires liés à l'interface, pas dans une classe séparée.

🔍

Découvrabilité

Les méthodes factory et auxiliaires se trouvent là où vous les attendez.

🧩

Cohésion d'API

Pas besoin de classes *Utils ou *Helper séparées.

Ancienne Approche
Classes utilitaires
Approche Moderne
Méthodes statiques dans les interfaces
Depuis JDK
8
Difficulté
Débutant
Support JDK
Méthodes statiques dans les interfaces
Disponible

Disponible depuis JDK 8 (mars 2014)

Comment ça fonctionne

Avant Java 8, les méthodes utilitaires liées à une interface devaient résider dans une classe séparée (ex. Collections pour Collection). Les méthodes statiques dans les interfaces permettent de garder les utilitaires liés ensemble. C'est courant dans les APIs modernes comme Comparator.comparing(), Stream.of() et List.of().

Documentation Associée
Evolving Interfaces (dev.java) ↗
Patterns associés
Language Intermédiaire

Default interface methods

Java 7
// Need abstract class to share behavior
public abstract class AbstractLogger {
    public void log(String msg) {
        System.out.println(
            timestamp() + ": " + msg);
    }
    abstract String timestamp();
}

// Single inheritance only
public class FileLogger
    extends AbstractLogger { ... }
Java 8+
public interface Logger {
    default void log(String msg) {
        IO.println(
            timestamp() + ": " + msg);
    }
    String timestamp();
}

// Multiple interfaces allowed
public class FileLogger
    implements Logger, Closeable { ... }
Survolez pour voir le moderne ➜
JDK 8+ →
Language Intermédiaire

Private interface methods

Java 8
interface Logger {
    default void logInfo(String msg) {
        System.out.println(
            "[INFO] " + timestamp() + msg);
    }
    default void logWarn(String msg) {
        System.out.println(
            "[WARN] " + timestamp() + msg);
    }
}
Java 9+
interface Logger {
    private String format(String lvl, String msg) {
        return "[" + lvl + "] " + timestamp() + msg;
    }
    default void logInfo(String msg) {
        IO.println(format("INFO", msg));
    }
    default void logWarn(String msg) {
        IO.println(format("WARN", msg));
    }
}
Survolez pour voir le moderne ➜
JDK 9+ →
Collections Débutant

Immutable list creation

Java 8
List<String> list =
    Collections.unmodifiableList(
        new ArrayList<>(
            Arrays.asList("a", "b", "c")
        )
    );
Java 9+
List<String> list =
    List.of("a", "b", "c");
Survolez pour voir le moderne ➜
JDK 9+ →
Partager 𝕏 🦋 in ⬡