Default Interface Method in Java8

This article explains Default Interface Methods introduced in Java8 and how to use them in multiple inheritance scenarios.

 

Interface default methods

 

Prior to JDK 8, an interface could not contain any implementation. Interfaces contain only constants and method signatures.

 

Beginning JDK 8, it is possible to define default implementation for a method in an interface. These methods are called default methods.

Java 8 default interface method

A default method is declared using a keyword “default” and it contains a method body.

 

A default method is available to all implementing classes of the interface. If the implementation class wants to use it, it can use it or it can ignore the default implementation and create its own implementation.

 

Even though an interface can now define default methods, the interface must still be implemented by a class if an instance is to be created.

 

Here is an example of interface with a  default method :

 

package java8;

public interface MyIF {
  
  int add(int x, int y);
  
  //default method
  default int multiply(int x, int y){
    return x*y;
  }
}


The above interface declares an abstract method add() and a default method multiply().

 

Let’s create a class implementing this interface. Note that, an implementing class is only required to implement the abstract method. The default method can be used as is unless the implementing class wants to change the behaviour.

 

package java8;

public class MyClass implements MyIF {

  public int add(int x, int y) {
    return x+y;
  }

}


 

The above class MyClass implements the MyIF interface and provides implementation of add() method.

 

Now, if we create an instance of MyClass and call the multiply() method, the default method implementation will be used as shown below :

 

package java8;

public class DefaultMethodDemo1 {

  public static void main(String[] args) {
    MyIF intRef = new MyClass();
    
    System.out.println("Sum = " + intRef.add(5,10));
    
    System.out.println("Product = " + intRef.multiply(5,10));
  }

}


 

The above program will output :

Sum = 15
Product = 50

 

Since, the implementing class MyClass didn’t override multiply(), default method behaviour was used.

 

Multiple inheritance issues with Default methods

 

Java doesn’t support multiple inheritance of classes, however a class can implement multiple interfaces.

 

So, what happens when a class implements multiple interfaces with the same default method ?

 

There could be 3 scenarios here.. here is what will happen in each of the scenarios.

 

Scenario 1 : Class implements both interfaces without overriding the default method

 

Let’s create two interfaces InterfaceA and InterfaceB that provide the default method hello() and a class implementing both these interfaces.

 

Now, the implementing class extends default method behaviour from both interfaces. So, if the implementing class does not implement the hello() method, a compilation error will occur for duplicate method declaration.

 

Here is the code :

 

package java8;

public interface InterfaceA {

  default void hello(){
    System.out.println("Hello A");
  }
}

package java8;

public interface InterfaceB {

  default void hello(){
    System.out.println("Hello B");
  }
}

package java8;

//Compile error for duplicate default method names
public class MultipleDefaultdemo implements InterfaceB, InterfaceA {

  public static void main(String[] args) {
    
  }

}


 

Scenario 2 : Class overrides the default method

 

If we provide implementation for hello() in MultipleDefaultdemo class, then the default method will be overridden and the class’s hello() method will be used.

 

It is possible to explicitly refer to a default implementation in an inherited interface using super keyword.

 

The general form for this is :

InterfaceName.super.DefaultMethodName();

 

So, we can access the default method hello() in InterfaceA and InterfaceB as follows :

 

InterfaceA.super.hello();

InterfaceB.super.hello();

 

Here is the complete example :

 

package java8;

public class MultipleDefaultdemo implements InterfaceB, InterfaceA {

  public static void main(String[] args) {
    new MultipleDefaultdemo().hello();
  }

  public void hello(){
    System.out.println("Hello Class");
    InterfaceA.super.hello();
    InterfaceB.super.hello();
  }
}


 

Running the above program will generate output :

Hello Class

Hello A

Hello B

 

 

Scenario 3 : One interface extends another with same default method

 

In cases where one interface extends another, with both defining a common default method, the inheriting interface’s version of the method takes precedence.

 

So, if InterfaceB extends InterfaceA, then InterfaceB’s version of method hello() will be used.

 

Here is the code for the same :

 

package java8;

public interface InterfaceA {

  default void hello(){
    System.out.println("Hello A");
  }
}

package java8;

public interface InterfaceB extends InterfaceA{

  default void hello(){
    System.out.println("Hello B");
  }
}

package java8;

public class MultipleDefaultdemo implements InterfaceB, InterfaceA {

  public static void main(String[] args) {
    new MultipleDefaultdemo().hello();
  }

}


Running this will produce output :

Hello B

 

Difference between Interface with Default method and Abstract class

 

When we add default method to an interface, it looks like an abstract class, but they are not the same.

 

An abstract class can have constructors, instance variables, concrete methods, but we can’t have instance variables or constructors in the interface.

 

An interface with single default method can be used to refer to a lambda expression, but an abstract class cannot be used to refer to lambda expressions.

Read more on the difference between Interface with Default method and Abstract class here :

Interface with default method vs Abstract class

 

You may also like :

 

Java8 Streams

Java8 Interview Questions

Java 8 new features

Top 10 Tricky Java Puzzles

Top 10 Recursion Coding Interview Questions

Top Java Tutorial Articles : March 2016

 

© 2015 – 2016, https:. All rights reserved. On republishing this post, you must provide link to original post

You may also like...

1 Response

  1. December 13, 2015

    […] Default Interface Method in Java8 […]

Leave a Reply.. code can be added in <code> </code> tags

%d bloggers like this: