Understanding the Difference Between Static and Default Methods in a Java Interface

What are the differences between static and default methods in a Java interface?

public interface SampleInterface {
    // Static method
    public static void staticMethod() {
        System.out.println("Static method in Interface");
    }

    // Default method
    public default void defaultMethod() {
        System.out.println("Default method in Interface");
    }
}

In Java, interfaces are a critical part of the language's object-oriented programming model, allowing methods to be defined that must be implemented by classes. With Java 8 and later, two new types of methods can be defined in interfaces: static methods and default methods. Each serves a different purpose within the interface, impacting how they can be used and overridden.

public interface SampleInterface {
    // Static method
    public static void staticMethod() {
        System.out.println("Static method in Interface");
    }

    // Default method
    public default void defaultMethod() {
        System.out.println("Default method in Interface");
    }
}

class ImplementationClass implements SampleInterface {
    public void defaultMethod() {
        System.out.println("Overridden default method in ImplementationClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // Calling static method
        SampleInterface.staticMethod();
        
        // Creating an instance of ImplementationClass to call the default method
        ImplementationClass obj = new ImplementationClass();
        obj.defaultMethod();
    }
}

Causes

• Static methods belong to the interface itself and can be called without creating an instance of the interface.
• Default methods provide a default implementation that can be inherited or overridden by implementing classes.

Solutions

• Static methods in an interface can be called directly using the interface name, e.g., SampleInterface.staticMethod();
• Default methods require an instance of a class that implements the interface to be invoked, e.g., new ImplementationClass().defaultMethod();

Mistake: Not understanding that static methods cannot be overridden in implementing classes.

Solution: Remember that static methods are associated with the interface, not its implementations.

Mistake: Confusing default methods with abstract methods and thinking they must always be overridden.

Solution: Default methods provide optional behavior; they can be overridden but are not required.