”;
Java Default Methods
Java introduced a new concept of default method implementation in interfaces in Java 8. Prior to Java8, an interface could have only abstract methods. Default method capability was added for backward compatibility so that old interfaces could be used to leverage the lambda expression capability of Java 8.
For example, List or Collection interfaces do not have ”forEach” method declaration. Thus, adding such method will simply break the collection framework implementations. Java 8 introduces default method so that List/Collection interface can have a default implementation of forEach method, and the class implementing these interfaces need not implement the same.
Syntax
The following is the syntax of the default method in interface in Java –
public interface vehicle {
default void print() {
System.out.println("I am a vehicle!");
}
}
Java Default Method Example
package com.tutorialspoint;
interface vehicle {
// default method must have an implementation
default void print() {
System.out.println("I am a vehicle!");
}
}
// implementing class needs not to implement the default method
// of an interface.
public class Tester implements vehicle {
public static void main(String args[]) {
Tester tester = new Tester();
// implementing class can access the default method as its own method
tester.print();
}
}
Let us compile and run the above program, this will produce the following result −
I am a vehicle!
Default Methods in Multiple Inheritance
With default functions in interfaces, there is a possibility that a class is implementing two interfaces with same default methods. The following code explains how this ambiguity can be resolved.
public interface vehicle {
default void print() {
System.out.println("I am a vehicle!");
}
}
public interface fourWheeler {
default void print() {
System.out.println("I am a four wheeler!");
}
}
First solution is to create an own method that overrides the default implementation.
public class car implements vehicle, fourWheeler {
public void print() {
System.out.println("I am a four wheeler car vehicle!");
}
}
Example: Overriding default method of interfaces with own implementation
In this example, we”ve created two interfaces with same default method print(). As Car class is implementing both the interfaces, so it has to override the default method otherwise compiler will complain for duplicate default methods. After overriding the default method with own implementation, we can easily use the print method of the Car class as shown below:
package com.tutorialspoint;
interface Vehicle {
default void print() {
System.out.println("I am a vehicle!");
}
}
interface FourWheeler {
default void print() {
System.out.println("I am a four wheeler!");
}
}
class Car implements Vehicle, FourWheeler {
// overriding the default method will resolve the ambiguity
public void print() {
System.out.println("I am a four wheeler car vehicle!");
}
}
public class Tester {
public static void main(String args[]) {
Car car = new Car();
car.print();
}
}
Let us compile and run the above program, this will produce the following result −
I am a four wheeler car vehicle!
Second solution is to call the default method of the specified interface using super.
public class car implements vehicle, fourWheeler {
public void print() {
vehicle.super.print();
}
}
Example: Calling default method of interfaces
In this example, we”ve created two interfaces with same default method print(). As Car class is implementing both the interfaces, so it has to override the default method otherwise compiler will complain for duplicate default methods. After overriding the default method with own implementation, we can easily use the print method of the Car class as shown below:
package com.tutorialspoint;
interface Vehicle {
default void print() {
System.out.println("I am a vehicle!");
}
}
interface FourWheeler {
default void print() {
System.out.println("I am a four wheeler!");
}
}
class Car implements Vehicle, FourWheeler {
// use the default method of a interface
public void print() {
FourWheeler.super.print();
}
}
public class Tester {
public static void main(String args[]) {
Car car = new Car();
car.print();
}
}
Let us compile and run the above program, this will produce the following result −
I am a four wheeler!
Static Default Methods in Java
An interface can also have static default methods from Java 8 onwards. These static methods acts as helper or utility functions and helps in better encapsulation of code.
public interface vehicle {
default void print() {
System.out.println("I am a vehicle!");
}
static void blowHorn() {
System.out.println("Blowing horn!!!");
}
}
Example: Calling static default method of interface
In this example, we”ve created two interfaces with same default method print(). As Car class is implementing both the interfaces, so it has to override the default method. After overriding the default method with calls to interfaces implementation, we”ve called the static method directly as shown below:
package com.tutorialspoint;
interface Vehicle {
default void print() {
System.out.println("I am a vehicle!");
}
static void blowHorn() {
System.out.println("Blowing horn!!!");
}
}
interface FourWheeler {
default void print() {
System.out.println("I am a four wheeler!");
}
}
class Car implements Vehicle, FourWheeler {
public void print() {
// call the Vehicle interface default print method
Vehicle.super.print();
FourWheeler.super.print();
// call the Vehicle interface static blowHorn method
Vehicle.blowHorn();
System.out.println("I am a car!");
}
}
public class Tester {
public static void main(String args[]) {
Vehicle vehicle = new Car();
vehicle.print();
// call the Vehicle interface static blowHorn method
Vehicle.blowHorn();
}
}
Let us compile and run the above program, this will produce the following result −
I am a vehicle! I am a four wheeler! Blowing horn!!! I am a car! Blowing horn!!!
”;