Diamond Problem in Java

Inheritance in Java

Inheritance is a fundamental concept in object-oriented programming (OOP) where a new class (subclass or derived class) is created based on an existing class (superclass or base class). The subclass inherits the properties and behaviors (methods and variables) of the superclass, allowing code reuse and promoting modularity and extensibility in software development.

In Java, inheritance is implemented using the extends keyword. The subclass inherits all non-private members (methods and variables) of the superclass and can add its own members or override superclass methods to provide specialized behavior. This enables the creation of class hierarchies, where subclasses can further extend the functionality of their parent classes.

Multiple Inheritance

In Multiple Inheritance of Object Oriented Programming, a child class is inherited from multiple classes.

Implementation Code

• Java

Java

import java.io.*;

class A 
{
 // Function inside Superclass A.
 void NinjaDisplay()
 {
    System.out.println("Class A Invoked");
 }
}

class B 
{
 // Function inside Superclass B.
 void NinjaDisplay()
 {
    System.out.println("Class B Invoked");
 }
}

// Multiple Inheritance
class C extends A, B 
{
 // Main driver function
 public static void main(String args[]) 
{
   // Creating object of class in main() function.
   C NinjaObject = new C();
   // Calling function of the Superclass creates ambiguity.
   NinjaObject.NinjaDisplay();
 }
}

You can also try this code with Online Java Compiler

Run Code

Output

Explanation

In the above example, Class C inherits from classes A and B and has access to their NinjaDisplay() function. Therefore, the compiler gets confused when we call the method NinjaDisplay() from class C. 
It can't be able to decide which NinjaDisplay() function should execute and throw an error. Therefore, in the case of Java Programming Language, Multiple Inheritance is not allowed. Multiple Inheritance creates ambiguity problems. 

Diamond Problem in Java

Diamond problems in Java Programming Language may occur when a class(subclass) inherits from multiple classes with a common ancestor(superclass). There might be a chance that both parent classes have the same method with the same name and arguments. That causes ambiguity during runtime. It makes it difficult for the compiler to choose which method to call. Therefore Java does not allow Multiple inheritances to avoid Diamond Problem. 

Java does not allow Multiple Inheritance. For a demonstration of the Diamond Problem, we are assuming that Java allows Multiple Inheritance. In the below diagram, we make class A the superclass of class B and class C. Class B and Class C are a subclass of class A. Also, class B and class C are superclasses for class D. Class D is a common child of class B and class C. Because of this Diamond Like structure, we call this problem a Diamond problem.

• Java

Java

import java.io.*;
class A 
{ 
public void NinjaDisplay() 
{ 
       System.out.println("Class A Invoked"); 
} 
}
// Inherits Functions of Class A 
class B extends A 
{ 
@Override 
public void NinjaDisplay()
{ 
       System.out.println("Class B Invoked"); 
} 
} 
// Inherits Functions of Class A
class C extends A 
{ 
@Override 
public void NinjaDisplay() 
{ 
       System.out.println("Class C Invoked"); 
} 
} 
//Multiple Inheritance 
public class D extends B, C 
{ 
public static void main(String args[]) 
{ 
       D NinjaObject = new D(); 
       //Creates ambiguity which NinjaDisplay() method to call 
       NinjaObject.NinjaDisplay();  
} 
}

You can also try this code with Online Java Compiler

Run Code

Output

Explanation

In the above program, we call NinjaDisplay() function from class D. Since class B and class C inherit from class A and Override its NinjaDisplay() function. Similarly, class D inherits from classes B and C and has access to their NinjaDisplay() function. Therefore, the compiler gets confused when we call the method NinjaDisplay() from class D. It can't be able to decide which NinjaDisplay() function should execute. It will result in Ambiguity and Program Crashing.

Solution of Diamond Problem in Java

The Diamond Problem in Java can be solved using default and interface keywords. These two keywords combined allow Multiple Inheritance without any ambiguity. Those methods are discussed below -

Interface 

It is used in Java to describe the class's behaviour. We used the interface as an abstract in Java. It represents the blueprint of the behaviour. We have only the abstract and variable in the interface, not the method's body. Similar to class, the interface also has a method, but those are declared as abstract. The body of the abstract will be further defined in class. In the interface, we don't have a constructor. To declare an interface, we should have to use the interface keyword. By default, all the methods defined in an interface are public.

Code Implementation

• Java

Java

import java.io.*;

// Defining interface
interface NinjaInterface 
{
   // Public, static and final.
   final int x = 100;

   // Publicly accessible abstract.
   void NinjaDisplay();
}

// Class that implements the NinjaInterface.
class NinjaClass implements NinjaInterface 
{
   // Defining the function definition.
   public void NinjaDisplay()
   {
   System.out.println("Welcome Ninjas!!");
   }

   // Main function
   public static void main(String[] args)
   {
       NinjaClass obj = new NinjaClass();

       // Calling NinjaDisplay.
       obj.NinjaDisplay();

       // Accessing public variable of NinjaInterface.
       System.out.println(x);
   }
}

You can also try this code with Online Java Compiler

Run Code

Output

Default

In previous versions of Java, we have only abstract methods. This means we first need to declare an abstract in Interface and later define its definition in their corresponding class. We can use the default method to get rid of this barrier. The default keyword allows interfaces to declare methods with its implementation. It doesn't affect the classes in which it will be implemented. It provides backward compatibility with the Interface.

Code Implementation

• Java

Java

import java.io.*;

interface NinjaInterface
{
   // Using the abstract method
   public void NinjaPowerOfTwo(int x);
   // Using the default method
   default void NinjaDisplay()
   {
       System.out.println("Default Method Invoked");
   }
}
 class NinjaClass implements NinjaInterface
{
   // Defining abstract of interface
   public void NinjaPowerOfTwo(int x)
   {
       System.out.println(x*x);
   }
   public static void main(String args[])
   {
       NinjaClass obj = new NinjaClass();
       obj.NinjaPowerOfTwo(10);
        // Default method executed
       obj.NinjaDisplay();
   }
}

You can also try this code with Online Java Compiler

Run Code

Output

Solution Code

• Java

Java

import java.io.*;

// Defining first interface.
interface NinjaInterfaceOne{ 

  /* Declaring a public variable belonging to itself. */
  public static int num = 3;

  /* Defining the function with its body using the default keyword. */
  public default void NinjaDisplay() {
     System.out.println("NinjaInterfaceOne is Invoked");
  }
}

// Defining second interface.
interface NinjaInterfaceTwo{

  /* Declaring a public variable belonging to itself. */
  public static int num = 30;

  /* Defining the function with its body using the default keyword. */
  public default void NinjaDisplay() {
     System.out.println("NinjaInterfaceTwo is Invoked");
  }
} 

// Performing multiple inheritances using class blueprints.
public class NinjaClass implements NinjaInterfaceOne, NinjaInterfaceTwo{
 
  public void NinjaDisplay() {

     // Here super keyword refers to the superclass.
     NinjaInterfaceOne.super.NinjaDisplay();
     NinjaInterfaceTwo.super.NinjaDisplay();
  }   

  // Main function. 
  public static void main(String args[]) {
     NinjaClass obj = new NinjaClass();
     obj.NinjaDisplay();
  }
}

You can also try this code with Online Java Compiler

Run Code

Output

Explanation

In the above code, we use an interface instead of a class. The interface replaces the class and is used as a blueprint of the class in the above code. Here we are not required to override these methods. We can declare multiple interfaces with the same methods and parameters. All can be invoked by an interface name and don't create any ambiguity. In this way, it also allows multiple inheritances in Java and solves Diamond Problem.

Frequently Asked Questions

How to resolve diamond problem in Java?

The diamond problem in Java can be resolved by using interfaces. Instead of multiple inheritance through classes, implement interfaces, which allow multiple classes to provide method implementations, resolving ambiguity and ensuring a clear inheritance hierarchy.

What type of inheritance leads to diamond problem?

The diamond problem occurs with multiple inheritance, specifically when a class inherits from two or more classes that share a common ancestor. This can lead to ambiguity in method resolution and conflicts in the inheritance hierarchy.

What is a real-world example of the diamond problem?

A real-world example of the diamond problem occurs in a class hierarchy where multiple classes inherit from a common superclass, and a subclass inherits from two or more of these classes, leading to ambiguity in method resolution.

Why doesn’t the Diamond Problem occur with classes in Java?

The Diamond Problem doesn't occur in Java because it doesn't support multiple inheritance with classes. Instead, Java uses interfaces to achieve similar functionality, resolving ambiguity by requiring explicit implementation of methods in the derived class.

Conclusion

In this article, we discussed the Diamond Problem in Java. The Diamond Problem highlights the complexities of multiple inheritance, particularly when dealing with method ambiguity. While Java avoids this issue by disallowing multiple inheritance with classes, it provides a robust alternative through interfaces. By requiring explicit method implementation and utilizing features like default methods, Java ensures flexibility and clarity, allowing developers to harness the benefits of inheritance without the pitfalls of ambiguity.

You can visit our other related blogs for more information on these topics.

• Java Tokens
• Multiple Inheritance in Java
• Default Constructor in Java
• Delegation Event Model in Java
• Access modifiers in java
• Swap Function in Java