Startseite / Language / Statische Methoden in Interfaces
Language Einsteiger

Statische Methoden in Interfaces

Statische Hilfsmethoden direkt in Interfaces hinzufügen, anstatt separate Hilfsklassen zu verwenden.

Code-Vergleich
✕ 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)) { ... }
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
📦

Bessere Organisation

Verwandte Hilfsfunktionen beim Interface behalten, nicht in einer separaten Klasse.

🔍

Auffindbarkeit

Factory- und Hilfsmethoden sind dort zu finden, wo man sie erwartet.

🧩

API-Kohäsion

Keine separaten *Utils- oder *Helper-Klassen mehr erforderlich.

Alter Ansatz
Hilfsklassen
Moderner Ansatz
Statische Interface-Methoden
Seit JDK
8
Schwierigkeitsgrad
Einsteiger
JDK-Unterstützung
Statische Methoden in Interfaces
Verfügbar

Verfügbar seit JDK 8 (März 2014)

Wie es funktioniert

Vor Java 8 mussten Hilfsmethoden, die sich auf ein Interface bezogen, in einer separaten Klasse leben (z. B. Collections für Collection). Statische Methoden in Interfaces erlauben es, verwandte Hilfsfunktionen zusammenzuhalten. Gängig in modernen APIs wie Comparator.comparing(), Stream.of() und List.of().

Zugehörige Dokumentation
Evolving Interfaces (dev.java) ↗
Verwandte Muster
Language Fortgeschritten

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 { ... }
Hover für Modernes ➜
JDK 8+ →
Language Fortgeschritten

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));
    }
}
Hover für Modernes ➜
JDK 9+ →
Collections Einsteiger

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");
Hover für Modernes ➜
JDK 9+ →
Teilen 𝕏 🦋 in ⬡