In this post, we will show you in detail about default methods in Java and their use. The default method is also known as “defender method” or “virtual extension method”. So, starting from Java 8, if a new method added to an interface, and if it is not required by all classes implementing this interface, we can mark it as “ default“. Default methods are methods that can have a body. “ default” keyword is used to denote a default method. In simple words, these are non-abstract methods implementations in interfaces, that are accessible to all classes who implements this interface, but the classes are not forced to override these methods. Java 8 introduced a lot of new important features including default methods.

This post covers the default methods in Java 8. Java 8 brought a number of new and interesting new features, including lambda expressions, functional interfaces streams, Optional. Members of an interface are always publicly accessible, whether explicitly declared or not. You can learn more from the Java Language Specification, §6.6. Unlike regular interface methods, we declare them with the default keyword at the beginning of the method signature, and they provide an implementation. Without an access modifier, a class member is accessible throughout the package in which its declared. We must override the default methods explicitly with its interface name.In this post, we will quickly discuss and cover default methods in Java. Like regular interface methods, default methods are implicitly public there’s no need to specify the publicmodifier. It allows us to implement these two interfaces, from a class. The advantage of interfaces is that it can have the same default methods with the same name and signature in two different interfaces. Because they are already implementing these interfaces. The only difference is that it is defined inside the interfaces with the default implementation. The default method is similar to the abstract method. We can achieve multiple inheritance by using these two things. The solution to the diamond problem is default methods and interfaces. It is sometimes referred to as the deadly diamond of death. It is a serious problem for other OPPs languages. It is an ambiguity that can rise as a consequence of allowing multiple inheritance. In the above figure, we find that class D is trying to inherit form class B and class C, that is not allowed in Java. What Java does not allow is multiple inheritance where one class can inherit properties from more than one class. For example, class C can inherit its property from B class which itself inherits from A class. With Java 8, we can add the default implementation. Before Java 8, if a new method was added to an interface, then all the implementation classes of that interface were bound to override that new method, even if they did not use the new functionality. Multi-level inheritance allows a child class to inherit properties from a class that can inherit properties from some other classes. Default methods in an interface allow us to add new functionality without breaking old code. for example, if class B inherits properties from only one super-class A, then it is called simple inheritance, and Java supports them. But remember that Java does not support the multiple inheritance because of the diamond problem.Īs simple inheritance allows a child class to derive properties from one super-class. There are different types of inheritance such as, single, multiple, multi-level, and hybrid inheritance. Inheritance is a very popular property in an object-oriented programming language, such as C++, Java, etc. The diamond problem is a common problem in Java when it comes to inheritance. Hence, it will be good to avoid it for making things simple. It creates problems during various operations, for example, constructor chaining and casting. Default methods, also known as virtual extension methods or defender methods is a non-abstract method, which can be declared inside an interface in Java. In particular, default methods enable you to add methods that accept lambda expressions as parameters to existing interfaces. When we compile the above program, it shows the compiler error, as we have shown below.ĭue to these complications and ambiguities, Java does not support multiple inheritance. Default methods enable you to add new functionality to existing interfaces and ensure binary compatibility with code written for older versions of those interfaces. Assume that we need to call the display() method by using the object of class D, in this scenario Java compiler does not know which display() method to call. Class D inherits the class B and class C (which is invalid in Java).The display() method of class A is overridden by the class B and class C. The default method in a Java interface is a concrete (non-abstract) method that will be called at runtime if the implementation is missed by the implementor. Class B and class C inherits the class A.

creates ambiguity which display() method to call

Default methods in java interface