Default Methods in Java 8

Default methods, also known as defender methods or virtual extension methods, are a feature introduced in Java 8. They allow interfaces to have concrete method implementations, providing a way to add new methods to an existing interface without breaking backward compatibility.

Key Features

• Interface Enhancements: Default methods were introduced to enhance the capabilities of interfaces in Java. Before Java 8, interfaces could only declare abstract method signatures, but with default methods, interfaces can provide default implementations for methods.
• Backward Compatibility: Default methods were designed to ensure backward compatibility when introducing new methods to existing interfaces. Existing classes implementing the interface will automatically inherit the default method implementation without requiring any changes to their code.
• Multiple Inheritance: Default methods also address the problem of multiple inheritance in interfaces. If a class implements multiple interfaces with conflicting method signatures, it can use the default method implementation from one of the interfaces or override it with its own implementation.

Syntax

The syntax for declaring a default method in an interface is as follows:

default returnType methodName(parameterList) {
    // Method implementation
}

Example

Here's an example that demonstrates the use of default methods in Java 8:

interface Vehicle {
    void start();

    default void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car started");
    }
}

public class DefaultMethodExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.stop();
    }
}

Output:

Car started
Vehicle stopped

In this example, we define an interface called Vehicle with two methods: start() and stop(). The stop() method is a default method that provides a default implementation for stopping the vehicle.

The Car class implements the Vehicle interface and provides its own implementation of the start() method. Since the stop() method is a default method, the Car class inherits the default implementation provided by the Vehicle interface.

When we create an instance of the Car class and call the start() and stop() methods, the output shows that the start() method of Car is called, and the default implementation of stop() from the Vehicle interface is used.

Conclusion

Default methods in Java 8 provide a way to add new methods to interfaces without breaking existing implementations. They enhance the capabilities of interfaces by allowing them to have concrete method implementations. Default methods also address the issue of multiple inheritance in interfaces. By using default methods, you can evolve your interfaces over time while maintaining backward compatibility.

I hope this explanation helps you understand default methods in Java 8! Let me know if you have any further questions.