Java Language - 74 - Default Methods

Java 8 Features – Default Methods

Introduction to Default Methods

In Java 8, one of the most notable features introduced was the concept of default methods. These methods allow interfaces to provide method implementations without breaking existing classes that implement those interfaces. This feature revolutionized the way Java handles interfaces and greatly improved backward compatibility.

Why Default Methods?

Before Java 8, interfaces were limited to declaring method signatures that classes implementing them had to provide implementations for. However, adding a new method to an existing interface could potentially break all classes implementing it. To address this issue, default methods were introduced to provide a default implementation in the interface itself, which implementing classes can choose to override or use as is.

Defining a Default Method

To create a default method in an interface, you can use the default keyword. Here’s an example of an interface with a default method:


public interface MyInterface {
    void regularMethod();

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

In this example, defaultMethod is a default method that provides an implementation. Classes implementing MyInterface can call this method without providing their own implementation.

Overriding Default Methods

A class implementing an interface with a default method can choose to override the default method, providing its own implementation. The overridden method in the class takes precedence over the default method in the interface.


public class MyClass implements MyInterface {
    @Override
    public void regularMethod() {
        System.out.println("This is the implementation of the regular method.");
    }

    @Override
    public void defaultMethod() {
        System.out.println("This is the overridden default method.");
    }
}

In this case, MyClass has provided its own implementation of the defaultMethod and the regular regularMethod.

Multiple Inheritance of Default Methods

A class can implement multiple interfaces, and if these interfaces have default methods with the same name, the class must provide an implementation to resolve the conflict.


public interface InterfaceA {
    default void myMethod() {
        System.out.println("Method in InterfaceA");
    }
}

public interface InterfaceB {
    default void myMethod() {
        System.out.println("Method in InterfaceB");
    }
}

public class MyImplementation implements InterfaceA, InterfaceB {
    @Override
    public void myMethod() {
        InterfaceA.super.myMethod(); // Explicitly call InterfaceA's method
        InterfaceB.super.myMethod(); // Explicitly call InterfaceB's method
    }
}

In this example, MyImplementation provides its implementation of myMethod, and it explicitly calls the default methods from InterfaceA and InterfaceB</b.

Use Cases for Default Methods

Default methods are especially useful when extending interfaces that are part of Java’s standard libraries. Existing interfaces like java.util.List and java.util.Map have benefited from default methods to add new methods without breaking existing code. This allows for smoother evolution of the Java API.

Conclusion

Default methods introduced in Java 8 have significantly improved the flexibility and backward compatibility of interfaces in Java. They provide a powerful mechanism to add new methods to interfaces without affecting existing implementations. Developers can now extend and evolve their interfaces more conveniently, and the Java API itself has benefited from this feature’s introduction.

Java Language – 74 – Default Methods