Diamond problem in Java

The Diamond Problem in Java is connected to multiple inheritances. It is also referred to as the "deadly diamond dilemma" or even the "deadly diamond of death”. The solution for the diamond problem is based on the concept of inheritance.

Java Inheritance

A relationship between the parent and child classes is called inheritance. The parent class's characteristics are passed down to the child (subclass) (superclass). We use the term extends to define this relation.

Syntax:

public class Child extends Parent
{
}

Filename: Inheritance.java

//Java Program for inheritance
//importing the packages
import java.io.*;
import java.util.*;
class Birds
{  
void eats()
{
    System.out.println("The bird is eating...");
}  
}  
// Class Peacock inherited the properties of Birds() class
class Peacock extends Birds
{  
void jumping()
{
    System.out.println("The Peacock is jumping");
}  
}  
class Inheritance
{  
public static void main(String args[])
{  
Peacock p=new Peacock();  
p.jumping();  
p.eats();  
}
}  

Output

The Peacock is jumping
The bird is eating….

A superclass (parent class) duplicate is formed in the sub-class (child class) objects when we inherit the characteristics of one class into another class, for instance. Therefore, we may retrieve the superclass properties by using the sub-class object.

Multiple Inheritance

The ability of a class to inherit attributes from many parent classes is a characteristic of the object-oriented approach. When procedures with the same name and signatures exist both in the superclass and sub-class, the feature causes an issue. The compiler becomes confused whenever we call the method and need help deciding which class method should be called or whether the class method should be called first.

Filename:Dog.java

class Ant 
{  
public void displays()  
{  
System.out.println("The method displays() of class Ant is called");  
}  
}  
class Bat extends Ant  
{  
@Override  
public void displays()  
{  
System.out.println("class Bat displays() method is called");  
}  
}  
class Cat extends Ant  
{  
@Override  
public void displays()  
{  
System.out.println("class Cat displays() method is called");  
}  
}  
// an error arises in java
public class Dog extends Bat, Cat  
{  
public static void main(String args[])  
{  
Dog d1 = new Dog();  
//the displays() method is called 
d.displays();   
}  
}  

Class Ant is inherited by classes Bat and Cat. Class Bat and class Cat replace the displays() function of class A.

Consider a situation in which we need to use an object of class Dog to use the displays() method; in this case, the Java compiler cannot determine which displays() method to call. The class Dog inherits the classes Bat and Cat. (which is invalid in Java). As a result, it causes ambiguity.

The above program displays a compiler error when compiled, as demonstrated below.

Output

public class Dog extends Bat, Cat  
^
1 error

Java does not enable multiple inheritances due to these challenges and complexities. It causes issues with several actions, such as casting and function Object()  chaining. Therefore, avoiding it would be beneficial for keeping things simple.

The Diamond Problem

In Java, a common inheritance-related problem is known as the "diamond problem." In an object-oriented programming language like C++, Java, etc., inheritance is a highly common characteristic. Several inheritance patterns exist, including single, multiple, multi-level, and hybrid inheritance. But keep in mind that due to the diamond problem, Java does not enable multiple inheritances.

public class Dog extends Bat, Cat  
^
1 error

According to simple inheritance, a child class can inherit attributes from a single superclass. Simple inheritance is supported by Java, for instance, if class Bat inherits characteristics from just one superclass Ant.

It passes down ant class ability to inherit from other classes' properties to its children thanks to multi-level inheritance. For instance, class Bat, which descends from class Ant, can provide class Cat with a property. Java also supports them.

Multiple inheritances, where one class can inherit properties from multiple classes, is something that Java does not permit. It is referred to as the diamond problem. Class Dog is attempting to inherit from classes Bat and Cat in the preceding error, which is not permitted in Java.

The possibility of multiple inheritances might lead to this ambiguity. It poses a significant issue for other OPPs languages. It's also known as the "deadly diamond of death." 

Solution for Diamond Problem

The problem could be resolved by using default methods and interfaces. By combining these two concepts, we can achieve multiple inheritances. Similarly to that, some of the abstract methods are just the default method. The interfaces describe it with the default implementations, which is the sole difference. We don't have to override these techniques because they have already implemented these interfaces.

The benefit of interfaces is that identical default methods can exist in two separate interfaces that share the same name and declaration. From a class, it enables us to define these two interfaces. Must use the interface's name specifically to alter the default methods.

Syntax:

InterfaceName.super.methodName();

Filename: InheritanceDemo.java

//program for implementation of Diamond Problem
//importing the packages
import java.io.*;
import java.util.*;
interface InterfaceEx1
{  
public default void displays()   
{  
System.out.println("The method displays() from the InterfaceEx1 interface is initiated");
}  
}  
interface InterfaceEx2
{  
public default void displays()   
{  
System.out.println("The method displays() from the InterfaceEx2 interface is initiated");
}  
}  
public class InheritanceDemo implements InterfaceEx1, InterfaceEx2
{  
public void displays()   
{  
InterfaceEx1.super.displays();  
InterfaceEx2.super.displays();  
}  
public static void main(String args[])   
{  
InheritanceDemo object = new InheritanceDemo();  
object.displays();  
}  
}  

Output

The method displays() from the InterfaceEx1 interface is initiated
The method displays() from the InterfaceEx2 interface is initiated

We can see from the sample above that the method name and signature are the same across both interfaces. We have used an interface name to call the method, which prevents method ambiguities.

The program which does not contain the default methods

Filename: InheritanceDemo1.java

//program for implementation of Diamond Problem
//importing the packages
import java.io.*;
import java. util.*;
interface DiamondInterface
{   
//The default method of interface  
default void displays()   
{   
System.out.println("The displays() method is invoked");   
}   
}   
//the interface which does not consist of the default method
interface  DiamondInterface1 extends DiamondInterface
{   
      
}   
// The second interface, which doesn't contain any method
interface DiamondInterface2 extends DiamondInterface  
{  
      
}   
// the logic of implementation
public class InheritanceDemo1 implements  DiamondInterface1,DiamondInterface2  
{   
public static void main(String args[])   
{   
 InheritanceDemo1 object = new InheritanceDemo1();   
// the displays method is called
object.displays();   
}   
}  

Output

The displays() method is invoked

Explanation:

The default methods are removed in the DiamondInterface1 and DiamondInterface2 interfaces, but the method is invoked from the

DiamondInterface.