Static and Default method in interface

In Java 8, default and static methods were introduced in interfaces to provide a mechanism for adding new methods to interfaces without breaking backward compatibility. Before Java 8, interfaces could only declare abstract methods that had to be implemented by the classes implementing the interface. Let's explore default and static methods with examples:

Default Methods:

Definition:

• A default method is a method defined in an interface with a default implementation. It allows the interface to provide a method implementation that can be used by all classes implementing the interface.

Example:

interface Greeting {
    // Abstract method (to be implemented by implementing classes)
    void greet();

    // Default method with a default implementation
    default void defaultGreet() {
        System.out.println("Default Greeting");
    }
}

class EnglishGreeting implements Greeting {
    @Override
    public void greet() {
        System.out.println("Hello");
    }
}

class SpanishGreeting implements Greeting {
    @Override
    public void greet() {
        System.out.println("Hola");
    }
}

public class Main {
    public static void main(String[] args) {
        Greeting english = new EnglishGreeting();
        english.greet();            // Output: Hello
        english.defaultGreet();     // Output: Default Greeting

        Greeting spanish = new SpanishGreeting();
        spanish.greet();            // Output: Hola
        spanish.defaultGreet();     // Output: Default Greeting
    }
}

In this example, the Greeting interface has a default method defaultGreet(). Both EnglishGreeting and SpanishGreeting classes implement this interface. The defaultGreet() method can be invoked on instances of the implementing classes without providing an implementation in each class.

Static Methods:

Definition:

• A static method in an interface is a method that belongs to the interface itself, not to the instances implementing the interface. It can be called on the interface itself, not on instances of the interface.

Example:

interface MathOperations {
    // Abstract method (to be implemented by implementing classes)
    int operate(int a, int b);

    // Static method in interface
    static int add(int a, int b) {
        return a + b;
    }
}

class Calculator implements MathOperations {
    @Override
    public int operate(int a, int b) {
        return a - b;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperations calculator = new Calculator();

        // Calling static method from interface
        int sum = MathOperations.add(5, 3);
        System.out.println("Sum: " + sum);  // Output: Sum: 8

        // Calling implemented method
        int result = calculator.operate(10, 5);
        System.out.println("Result: " + result);  // Output: Result: 5
    }
}

In this example, the MathOperations interface has a static method add(int a, int b). This method can be called directly on the interface without creating an instance of the interface. The Calculator class implements the interface and provides an implementation for the operate method.

Default and static methods in interfaces provide a way to enhance existing interfaces without breaking the implementations. Default methods offer a default implementation that can be overridden by implementing classes, while static methods provide utility methods associated with the interface itself. These features contribute to better code organization and backward compatibility.