Home / Language / Static methods in interfaces
Language beginner

Static methods in interfaces

Add static utility methods directly to interfaces instead of separate utility classes.

Code Comparison
✕ 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)) { ... }
Why the modern way wins
📦

Better organization

Keep related utilities with the interface, not in a separate class.

🔍

Discoverability

Factory and helper methods are found where you'd expect them.

🧩

API cohesion

No need for separate *Utils or *Helper classes.

Old Approach
Utility classes
Modern Approach
Interface static methods
Since JDK
8
Difficulty
beginner
JDK Support
Static methods in interfaces
Available

Available since JDK 8 (March 2014)

How it works

Before Java 8, utility methods related to an interface had to live in a separate class (e.g., Collections for Collection). Static methods in interfaces let you keep related utilities together. Common in modern APIs like Comparator.comparing(), Stream.of(), and List.of().

Related Documentation
Related patterns
Language intermediate

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) {
        System.out.println(
            timestamp() + ": " + msg);
    }
    String timestamp();
}

// Multiple interfaces allowed
public class FileLogger
    implements Logger, Closeable { ... }
Hover to see modern ➜
JDK 8+ →
Language intermediate

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) {
        System.out.println(format("INFO", msg));
    }
    default void logWarn(String msg) {
        System.out.println(format("WARN", msg));
    }
}
Hover to see modern ➜
JDK 9+ →
Collections beginner

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 to see modern ➜
JDK 9+ →
Share 𝕏 🦋 in ⬡