Java Interface Evolution: Best Practices and Strategies

Source: Dev.to

Evolution of Java Interfaces – LTS Releases Since Java 8

📍 March 2014 – Java 8

The Functional Revolution

Java 8 transformed interfaces by allowing non‑abstract methods. This solved the interface‑evolution problem and opened the door to functional programming via functional interfaces.

New Interface Features

• Default methods – concrete implementations inside an interface (default keyword).
• Static methods – utility methods defined on the interface itself.
• Functional interfaces – interfaces with exactly one abstract method, usable with lambdas.

1. Default Methods

public interface MyInterface {
    void existingMethod();

    default void newDefaultMethod() {
        System.out.println("This is a default method.");
    }
}

public class MyClass implements MyInterface {
    @Override
    public void existingMethod() {
        System.out.println("Implementing existing method.");
    }

    // No need to implement newDefaultMethod() unless a custom behavior is required
    public void someMethod() {
        newDefaultMethod();   // calls the default implementation
    }
}

Real‑world examples

java.util.List – sort

public interface List extends Collection {
    default void sort(Comparator c) {
        Collections.sort(this, c);
    }
}

// Usage
List list = new ArrayList<>(Arrays.asList("banana", "apple", "cherry"));
list.sort(Comparator.naturalOrder());
System.out.println(list);   // → [apple, banana, cherry]

java.lang.Iterable – forEach

public interface Iterable {
    default void forEach(Consumer action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
}

// Usage
List list = Arrays.asList("apple", "banana", "cherry");
list.forEach(item -> System.out.println(item));

java.util.Map – several default methods

public interface Map {
    default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key)) ? v : defaultValue;
    }

    default V putIfAbsent(K key, V value) {
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }
        return v;
    }

    // … other default methods: remove, replace, compute, merge, …
}

// Usage
Map map = new HashMap<>();
map.put("apple", 1);
Integer i = map.getOrDefault("banana", 0);
System.out.println(i);   // → 0

2. Static Methods in Interfaces

public interface MyInterface {
    static void utilityMethod() {
        System.out.println("This is a static method in the interface.");
    }
}

public class MyClass implements MyInterface {
    public void someMethod() {
        MyInterface.utilityMethod();   // call the static method
    }
}

Utility‑class example – java.util.Collections

public final class Collections {
    public static List emptyList() {
        return (List) EMPTY_LIST;
    }
}

// Usage
List empty = Collections.emptyList();
System.out.println(empty);   // → []

Factory methods on Map

public interface Map {
    static Map of() {
        return new HashMap<>();
    }

    static Map of(K k1, V v1) {
        Map map = new HashMap<>();
        map.put(k1, v1);
        return map;
    }

    // … overloads for more entries …
}

// Usage
Map map = Map.of("apple", 1, "banana", 2);
System.out.println(map);   // → {apple=1, banana=2}

3. Functional Interfaces

@FunctionalInterface
public interface MyFunctionalInterface {
    void singleAbstractMethod();
}

// Lambda usage
MyFunctionalInterface func = () -> System.out.println("Lambda expression implementation.");
func.singleAbstractMethod();   // → Lambda expression implementation.

The java.util.function package

Predicate

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

// Usage
Predicate<String> isEmpty = str -> str.isEmpty();
System.out.println(isEmpty.test(""));      // → true
System.out.println(isEmpty.test("hello")); // → false

Function

@FunctionalInterface
public interface Function<T,R> {
    R apply(T t);
}

// Usage
Function<String,Integer> stringLength = s -> s.length();
System.out.println(stringLength.apply("hello")); // → 5
System.out.println(stringLength.apply(""));      // → 0

Consumer

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

// Usage
Consumer<String> printer = s -> System.out.println(s);
printer.accept("Hello, world!");   // → Hello, world!

Functional Interfaces in Java

java.util.function.Consumer

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

// Usage
Consumer<String> print = str -> System.out.println(str);
print.accept("hello");   // → hello
print.accept("world");   // → world

java.util.function.Supplier

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

// Usage
Supplier<Double> randomValue = () -> Math.random();
System.out.println(randomValue.get()); // → Random double value
System.out.println(randomValue.get()); // → Another random double value

java.util.function.UnaryOperator (extends Function)

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T,T> {}

// Usage
UnaryOperator<Integer> square = x -> x * x;
System.out.println(square.apply(5)); // → 25
System.out.println(square.apply(0)); // → 0

java.util.function.BinaryOperator (extends BiFunction)

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {}

// Usage
BinaryOperator<Integer> add = (x, y) -> x + y;
BinaryOperator<Integer> addWithMethodReference = Integer::sum;
System.out.println(add.apply(5, 10));                 // → 15
System.out.println(addWithMethodReference.apply(0,0)); // → 0

Pre‑Java 8 Functional‑Style Interfaces

These interfaces were defined before Java 8 and later qualified as functional interfaces.

Evolution of Interface Features

September 2018 – Java 11

Feature: Private methods in interfaces (introduced in Java 9, continued in Java 11).

public interface DataProcessor {

    default void process(String data) {
        String cleaned = sanitize(data);
        System.out.println("Processed: " + cleaned);
    }

    private String sanitize(String input) {
        return input.trim().toLowerCase();
    }

    static DataProcessor create() {
        return new DataProcessor() {};
    }
}

// Usage
public class TestInterfacePrivateMethod {
    public static void main(String[] args) {
        DataProcessor processor = DataProcessor.create();
        processor.process("  HELLO WORLD  "); // → Processed: hello world
    }
}

Java 11 is an LTS release but does not add new interface capabilities beyond the private‑method support.

September 2021 – Java 17

Feature: Sealed interfaces (alongside sealed classes).

// Sealed interface – only the listed types may implement it.
public sealed interface Shape permits Circle, Rectangle, Polygon {}

// Final class – cannot be subclassed.
final class Circle implements Shape {
    public final double radius;
    public Circle(double radius) { this.radius = radius; }
}

// Sealed subclass – continues the restriction.
sealed class Polygon implements Shape permits Quadrilateral {
    public final int sides;
    public Polygon(int sides) { this.sides = sides; }
}

// Non‑sealed class – can be freely extended.
non-sealed class Rectangle implements Shape {
    public final double width, height;
    public Rectangle(double w, double h) { width = w; height = h; }
}

Rules

• Subtypes must be listed in the permits clause (or be in the same source file).
• Each permitted subtype must be declared final, sealed, or non‑sealed.
• non‑sealed is allowed only on classes (or interfaces) that directly extend a sealed type.

September 2023 – Java 21

Feature: Pattern matching for switch (no new interface‑specific features).

sealed interface Expr permits Constant, Add {}

record Constant(int value) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}

public static int eval(Expr e) {
    return switch (e) {
        case Constant c -> c.value;
        case Add a      -> eval(a.left()) + eval(a.right());
    };
}

// Usage
Expr expr = new Add(new Constant(3), new Constant(5));
System.out.println(eval(expr)); // → 8

Best Practices for Interface Design

• Use default methods sparingly – they should add optional functionality, not alter the core contract.
• Consider impact on existing implementations – adding a default method may affect all current implementors.
• Prefer static methods for utilities – keep them closely related to the interface’s purpose.
• Document default and static methods clearly – explain intent, usage, and any side effects.
• Avoid state in interfaces – default methods should operate on the implementing class’s state, not maintain their own.

Closing Thought

Static Application Security Testing (SAST) remains a cornerstone of a mature Secure Software Development Lifecycle (SSDLC). It provides early, actionable insights, reduces risk, empowers developers, and fortifies applications before deployment. When SAST evolves from a mere detection tool into a catalyst for a long‑term secure engineering culture, the entire development ecosystem benefits.