Java 9 Private Interface Methods: Bessere Kapselung & Code-Wiederverwendung

Entwicklung der Interfaces

Motivation

default Methoden ermöglichen Implementierungen in Interfaces, führen aber oft zu Code-Duplikation, wenn mehrere Default-Methoden gemeinsame Logik teilen. private Methoden lösen dies: Sie sind nur im Interface sichtbar und können von default / static Methoden aufgerufen werden.

Beispiel: Logging-Interface

Vor Java 8 – Code-Duplikation in Implementierungen

interface Logging {
    void logInfo(String msg);
    void logWarn(String msg);
    void logError(String msg);
    void logFatal(String msg);
    void getConnection();
    void closeConnection();
}

class LogOracle implements Logging { ... } // alle Methoden implementiert, viel Duplikation
class LogMySql implements Logging { ... }  // dito

Java 8 – Default & Static Methoden im Interface

interface Logging {
    default void logInfo(String msg) { log(msg, "INFO"); }
    default void logWarn(String msg) { log(msg, "WARN"); }
    default void logError(String msg) { log(msg, "ERROR"); }
    default void logFatal(String msg) { log(msg, "FATAL"); }

    // Problem: log() muss default/static sein → öffentlich sichtbar!
    static void log(String msg, String level) { ... }
    static void getConnection() { ... }
    static void closeConnection() { ... }
}

Java 9 – Private Methoden für echte Kapselung

interface Logging {
    // Private Hilfsmethode – nicht nach außen sichtbar
    private void log(String msg, String level) {
        getConnection();
        System.out.println("Log: " + level + " - " + msg);
        closeConnection();
    }

    default void logInfo(String msg) { log(msg, "INFO"); }
    default void logWarn(String msg) { log(msg, "WARN"); }
    default void logError(String msg) { log(msg, "ERROR"); }
    default void logFatal(String msg) { log(msg, "FATAL"); }

    private static void getConnection() { System.out.println("DB connect"); }
    private static void closeConnection() { System.out.println("DB close"); }
}

class LoggerA implements Logging {}
class LoggerB implements Logging {}

Ausgabe bei Nutzung:

DB connect
Log: INFO - test
DB close
DB connect
Log: WARN - test
DB close
...

Regeln für private Interface-Methoden

• private Instanzmethoden: Können von default Methoden aufgerufen werden.
• private static Methoden: Können von default & static Methoden aufgerufen werden.
• Nicht von abstract Methoden (kein Body).
• Nicht überschreibbar / nicht in Subinterfaces sichtbar.
• Können nicht von implementierenden Klassen aufgerufen werden.

Vorteile

• DRY (Don't Repeat Yourself): Gemeinsame Logik einmal definieren.
• Kapselung: Implementierungsdetails bleiben im Interface verborgen.
• Binäre Kompatibilität: Private Methoden ändern sich nicht die öffentliche API.
• Testbarkeit: Interface-Logik kann via implementierende Test-Klasse indirekt geprüft werden.

Fazit

Private Interface-Methoden schließen eine Lücke in Java 8s Default-Methoden-Design und machen Interfaces zu echten, gekapselten Implementierungsträgern – ohne Implementierungsklassen zu belasten.