Let’s say in your legacy code, you have a class which is extending a base class as well as implementing your interface. This helps resolve ambiguity issues and also maintain backward compatibility with versions below Java SE 8. This can be considered as ‘class wins’ rule. However, you would notice that the compiler resolves to the class’s implementation by default and not the interface’s. Isn’t that great? Well it’s great especially for huge code bases but this default implementation gives rise to a major problem. You can say that default method implementation in interfaces from Java SE 8 onwards is similar to multiple inheritance as the default method is inherited by the class implementing it.

But now we can allow interfaces to have implementations to methods without changing the structure of the class implementing it. Earlier, if any new method had to be added to an existing interface, we also had to write its definition in the corresponding concrete class. What is a default method? 😕 A) Default methods were introduced in Java to help maintain our legacy code in a better way. And one of its major changes to the interface was the addition of default methods to interfaces. Now comes in Java SE 8 with its new features and its changes to the existing APIs. We have a single implementation of the function and the compiler doesn’t get confused. Since, both the function signatures are the same, it doesn’t matter which interface’s method is implemented in the concrete class. The implementation is done by the concrete class Dog. This case might look like a Diamond Head problem but trust me it isn’t, as both the interfaces’ methods don’t have any definitions. Let’s see a case in Java SE 7 (Lets take a simple case of Dogs this time): interface Bark Nope, implementation of multiple interfaces is NOT multiple inheritance (At least this was the case till Java SE 7). Implementing interfaces in Java can be seen as a class fulfilling contracts by implementing specific sets of rules declared in the contract (interface). Also, in Java SE 7 and below, we can’t define any methods in Java interfaces.

Java doesn’t support multiple inheritance from classes by default. This classic problem of Diamond Head is easily solved by using virtual inheritance in C++.ĭoes this problem occur in Java as well? 😕 Well, Yes and No.

What is legacy java se 6 runtime