Java Default Method

In Java 8, a new concept named the default method is introduced in order to perform backward compatibility that controls lambda expressions by old interfaces. Moreover, interfaces are allowed to have functions with implementation without causing any issues to the classes that interface will be implemented. Before the introduction of Java 8, only abstract methods are allowed by interfaces. Moreover, functions had to be offered in different classes. In the following sections, syntax, working, and examples of the default method will be explained.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Syntax

Below is the syntax of a default method.

public interface animal {
default void sound() {
System.out.println("This is a sample default method. . .!");
}}

How does the Default Method work in Java?

As we know, interfaces such as List and collections do not have the method forEach. If it is added, framework implementation of collections will break. Since the default method is introduced in Java 8, a default implementation can be done for the method forEach. In addition to that, a class that implements 2 interfaces with the same default functions can be done. Let us see how the ambiguity of the code is resolved.

public interface livingthings
{
default void sound()
{     . . .
System.out.println("Living things too make noise . . .") ;
}
}
public interface animals
{
default void sound()
{          . . .
System.out.println("animals too make noise . . .") ;
}
}

There are two solutions to this ambiguity.

1. To override the default method implementation, create your own method.

public class dogs implements livingthings,animals
{
default void sound()
{          . . .
System.out.println("dogs bark . . .") ;} }

2. Using super, call the default method

public class dogs implements livingthings,animals
{
default void sound()
{          . . .
livingthings.super.print("dogs bark . . .") ; } }

In Java, normally n interfaces can be implemented by a class. Moreover, an interface can be extended by another interface. Suppose there are two interfaces for a class and there is a default method implemented; the particular class may get confused in choosing which method to be considered for calling. In order to resolve these conflicts, the following points can be done.

• Overridden methods in the class are matched and called.
• If the method with the same method is provided, the most appropriate one will be chosen. Suppose there are two interfaces, A and B are present for a particular class. If A extends B, then A is the most specific here, and the default method will be selected from A. If A and b are independent interfaces, a severe conflict situation will occur, and a complaint will be raised by a compiler that it is unable to choose. In this situation, the user has to help the compiler by offering extra details from which A or B the default method has to be chosen. e.g.

A.super.demo() ;

or

B.super.demo() ;

Differences Between Normal Method and Default Method

Now, let us see some of the differences between a normal method and a default method

• The default method goes along with a default modifier, unlike normal methods.
• Arguments of the interfaces do not have any particular state for default methods.
• Normal methods can use as well as alter the arguments of the methods and class fields.
• New functionality can be added to the existing interfaces instead of breaking the previous implementation of those particular interfaces.

On extending an interface that consists of a default method, the following can be performed.

• The default method won’t be overridden, and it will be inherited.
• Default methods will be overridden, which are similar to methods that are overridden in subclasses.
• The default method should be again declared as abstract, which forces the subclass to be overridden.

Examples to Implement Java Default Method

The following are the sample programs mentioned:

Example #1

Java program to implement the default method

Code:

//Java program to implement default method
public class DefExample {
//main method
public static void main(String args[]) {
//create an object for the interface animal
Animals obj = new Dog();
//call the print method
obj.print( );
}
}
//create an interface animal
interface Animals {
//default method
default void print( ) {
System.out.println("I have four legs. . . ! !");
}
static void sound() {
System.out.println("I used to bark alot!!!") ;
}
}
//create an interface <u>carnivores</u>
interface Carnivores {
//default method
default void print( ) {
System.out.println("I eat non veg. . .! !") ;
}
}
//class that implements the other two interfaces
class Dog implements Animals, Carnivores {
public void print( ) {
//call the print method of Animals  using super
Animals.super.print( ) ;
//call the print method of Carnivores  using super
Carnivores.super.print( );
//call the sound method of Animals
Animals.sound();
System.out.println("I am a Dog . . .!");
}
}

Output:

Explanation: In this program, two interfaces, Animals and Carnivores, has the same default method print(), and they are called using super.

Example #2

Java program to implement the default method

Code:

//Java program to implement default method
interface Sampleinterface{
// Since this is declared as a default method, this has to be implemented in the implementation classes
default void sammethod(){
System.out.println("a default method which is newly added to the program");
}
// existing public as well as abstract methods has to be implemented in the implementation classes
void oldmethod(String s);
}
public class DefExample implements Sampleinterface{
//  abstract method implementation
public void oldmethod(String s){
System.out.println("The string given is: "+ s);
}
public static void main(String[] args) {
DefExample obj = new DefExample();
//call the default method
obj.sammethod();
//call the abstract method
obj.oldmethod("I am the old method in the program");
}
}

Output:

Explanation: In this program, an interface Sampleinterface is present, and it has a default method sammethod(), and it is called.

Conclusion

In Java 8, a new concept named the default method is offered for performing backward compatibility where old interfaces control lambda expressions. Moreover, interface arguments do not have any specific state for default methods. In this article, syntax, working, and examples of the default method are explained in detail.

The above is the detailed content of Java Default Method. For more information, please follow other related articles on the PHP Chinese website!