Can we override the default method?

Expert Posts
,
1

Java, default methods were introduced in Java 8 to allow interfaces to have methods with implementation. This provides backward compatibility, enabling interfaces to evolve without forcing all implementing classes to define the new methods. These methods are marked with the default keyword in an interface.

When a class implements an interface with a default method, it can either:

1. Inherit the default method as is, or

2. Override the default method to provide its own implementation.

How to Override a Default Method:

  1. Define the default method in the interface:
  2. The interface provides a default implementation of the method.
  3. Override the default method in the implementing class:
  4. The implementing class can override the default method by simply providing its own method with the same signature.

Example:

Interface with a Default Method:

interface Vehicle {
    default void start() {
        System.out.println("Starting the vehicle");
    }
}

Class that Overrides the Default Method:

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

public static void main(String[] args) {
Car car = new Car();
car.start(); // Output: Starting the car
}


}

In this example:

- The Vehicle interface has a default method start().

- The Car class implements Vehicle and overrides the default start() method with its own implementation.

When to Override a Default Method:

  • When the default behavior does not meet the specific needs of the implementing class.
  • To provide a custom implementation for certain classes while retaining the default behavior for others.

Can we call the default method after overriding?

Yes, you can still call the default method from the interface even after overriding it by using the following syntax:

Vehicle.super.start();  // Calls the default implementation in the interface

Example of Calling the Default Method:

public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Starting the car");
        Vehicle.super.start();  // Calls the default method from Vehicle interface
    }

public static void main(String[] args) {
Car car = new Car();
car.start();
// Output:
// Starting the car
// Starting the vehicle
}


}

Summary:

  • Yes, you can override default methods in Java by providing your own implementation in the implementing class.
  • You can still call the default method from the interface using InterfaceName.super.methodName().
  • Default methods in interfaces offer flexibility by allowing methods with implementation in interfaces, while still allowing classes to override them.

In conclusion, default methods can be overridden in Java to customize the behavior in implementing classes, while still allowing access to the default implementation if needed.