Diamond Problem

Question

Wikipedia on the diamond problem:

"... the diamond problem is an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If a method in D calls a method defined in A (and does not override the method), and B and C have overridden that method differently, then from which class does it inherit: B, or C?"

So the diamond looks like this:

  A  / \ B   C  \ /   D 

My question is, what happens if there is no such class A, but again B and C declare the same method, say foo(). Isn't this the same problem? Why is it then called diamond problem?

Example:

class B {     public void foo() {...} }  class C {     public void foo() {...} }  class D extends B, C { }  new D().foo(); 

Answer 1

Its not the same problem.

In the original problem, the overriden method can be called from A. In your problem this can't be the case because it does not exist.

In the diamond problem, the clash happens if class A calls the method Foo. Normally this is no problem. But in class D you can never know which instance of Foo needs to be called:

         +--------+          |   A    |          | Foo    |          | Bar    |          +--------+             /  \            /    \           /      \ +--------+        +--------+ |   B    |        |   C    | | Foo    |        | Foo    | +--------+        +--------+           \      /            \    /             \  /          +--------+          |   D    |          |        |          +--------+ 

In your problem, there is no common ancestor that can call the method. On class D there are two flavors of Foo you can chose from, but at least you know that there are two. And you can make a choice between the two.

+--------+        +--------+ |   B    |        |   C    | | Foo    |        | Foo    | +--------+        +--------+           \      /            \    /             \  /          +--------+          |   D    |          |        |          +--------+ 

But, as always, you do not need multiple inheritance. You can use aggegration and interfaces to solve all these problems.