Evolution of Interface in Java

In Java, interfaces define a contract for classes without specifying how the methods are implemented. With time, Java has introduced major enhancements or we can say evolution of interfaces to make them more powerful. So, in this article, we will explore the evolution of interfaces in Java from Java SE 7 to Java SE 21.

Interfaces in Java SE 7 and Earlier

In Java 7 or earlier, interfaces were very basic. They include only:

• Constant variables (implicitly public, static, and final)
• Abstract methods (implicitly public and abstract)

There was no way to provide method implementations inside interfaces.

Example:

public interface Geeks {
    String a = "Geeksforgeeks is the best.";

    void hello(String a);
    void world(int x);
}

Interfaces in Java SE 8 (Default and Static Methods)

After Java 7, Java 8 introduced a major change in interfaces. The change was the ability to add default and static methods in interfaces. This allowed developers to provide method implementations directly within interfaces.

Now, interfaces can contain:

• Constant variables
• Abstract methods
• Default methods
• Static methods

Example:

public interface Geeks {
    String b = "Sweta is an Employee.";

    default void hello(String a) {
        System.out.println("Hello");
    }

    static void world(int x) {
        System.out.println("World");
    }

    // still abstract
    void bye(); 
}
public interface Geeks {
    String b = "Sweta is an Employee.";

    default void hello(String a) {
        System.out.println("Hello");
    }

    static void world(int x) {
        System.out.println("World");
    }

    // still abstract
    void bye(); 
}

Interfaces in Java SE 9 (Private Methods in Interface)

From Java 9 onwards, interfaces can contain private methods. These became helpful for code reuse within default and static methods inside the same interface.

Now interfaces can have:

• Constant variables
• Abstract methods
• Default methods
• Static methods
• Private methods
• Private static methods

Example:

public interface Geeks {
    String b = "Sweta is an Employee.";

    default void hello(String a) {
        
        // calling private method
        greet(); 
    }

    static void world(int x) {
        System.out.println("World");
    }

    void bye();

    private void greet() {
        System.out.println("Greetings from GFG.");
    }

    private static void log() {
        System.out.println("Logging...");
    }
}

Interfaces in Java SE 15 and Java SE 16 (Sealed Interfaces)

Java 15 introduced sealed interfaces as a preview feature. Then Java 16 made them official. Sealed interfaces restricts which classes can implement them using the permits keyword.

Example:

public sealed interface Geeks permits GeeksImpl1, GeeksImpl2 {}

final class GeeksImpl1 implements Geeks {}
final class GeeksImpl2 implements Geeks {}

Interfaces in Java SE 21+ (Pattern Matching with Sealed Interfaces)

Java 21 has enhanced the sealed interfaces by supporting pattern matching in switch expressions. This simplifies complex type checks.

Example:

sealed interface Shape permits Circle, Square {}

final class Circle implements Shape {
    double radius;
}

final class Square implements Shape {
    double side;
}

public class Main {
    static void printArea(Shape shape) {
        switch (shape) {
            case Circle c -> System.out.println("Circle radius: " + c.radius);
            case Square s -> System.out.println("Square side: " + s.side);
        }
    }
}

Tabular Representation: