Multiple Inheritance :Java vs C++

Question

Recently ,after reading some articles in Programming Languages and Practice book ,it is mentioned that multiple interface inheritance in Java does not suffer from the same problems as multiple class inheritance in C++.

But I can't understand why this happens. How java is able to use multiple interface inheritance while in C++ implementation errors exists ??

Is there a way to replace multiple inheritance in C++ as to avoid implementation problems ??

For the last statement to be more specific ,lets say that we have:

class A {...};
class B : public A {...};
class C : public A {...};
class D : public B, public C {...};

Then class D inherits class B,C which both inherit class A. So if A had a field-variable then B,C would have the same variable name ,then what variable would D has (inherited from B or C) .To avoid this could we write the above code without multiple inheritance but with similar results?

The question is not a duplicate since it is not focused on what finally will be the inheritance in the example ,but to understand the difference between Java-C++ multiple inheritance(see the first question above) and also if there is a way suggested to overcome some multiple inheritance problems (like the above).

Answer 1

Java (unlike C++) does not allow multiple inheritance of state and, therefore, does not suffer from a diamond problem.

It allows multiple inheritance of type through interfaces (a class can implement multiple interfaces).

Starting with Java 8 there is also multiple inheritance of behavior through default methods in interfaces.

Answer 2

But I can't understand why this happens. How java is able to use multiple interface inheritance while in C++ implementation errors exists???

That is possible because Java does not allow multiple inheritance, but only multiple implementation from multiple interface.

Implementation is different than inheritance.

The general problem with multiple inheritance is (in short) that two classes may define different ways of doing the same thing, and the subclass can't choose which one to pick.

Since interface in java can only declare the signature of methods without implementing them, the problem does not exists if multiple interface are derived.

In conclusion, in order to avoid the problem Java forbids directly multiple inheritance, and allows only multiple implementation of interface.

---

Is there a way to replace multiple inheritance in c++ as to avoid implementation problems???

The first suggest I can give you is to avoid a design so complex.

Anyway the problem you've exposed in your question is very common and known as diamond problem.

C++ provides a solution in order to solve that problem with the usage of virtual inheritance.

Let an inheritance graph:

    A
 /     \
B       C
 \     /
    D

This is the problem:

C++ by default follows each inheritance path separately, so a D object would actually contain two separate A objects, and uses of A's members have to be properly qualified.

And this is a briefly explanation about the virtual inheritance:

If the inheritance from A to B and the inheritance from A to C are both marked "virtual" (for example, "class B : virtual public A"), C++ takes special care to only create one A object, and uses of A's members work correctly. If virtual inheritance and nonvirtual inheritance are mixed, there is a single virtual A and a nonvirtual A for each nonvirtual inheritance path to A.

In short, with virtual inheritance you prevent the part class A is duplicate in the class D.

Answer 3

To avoid this could we write the above code without multiple inheritance but with similar results?

It follows a minimal, working example:

struct A {};
struct B {};
struct C {};

struct D {
    operator A&() { return a; }
    operator B&() { return b; }
    operator C&() { return c; }

private:
    A a;
    B b;
    C c;
};

void f(const B &b) {}

int main() {
    D d;
    f(d);
}

If you don't want to create an explicit hierarchy, but still you would like to use an instance of D where a reference to B is required, the solution above works just well.
It is based on composition instead of inheritance, as you can see.
It has some limits, of course, as an example you cannot cast a pointer to D to a pointer to B.

If it fits your requirements mostly depends on the real problem, so I cannot say.
Anyway, that's is a viable solution somehow similar to the inner class idiom, if you are interested in having further details.

Answer 4

The "multiple inheritance" in Java is no real multiple inheritance. Since Java can only create the diamond problem by using interfaces.

Interfaces are only a reference to an implemented method in the sub class, because an interface cannot implement a method.

So the child class cannot have parents with different implementions. It doesn't matter from which interface you inherit the method, since no implementation exists.

Edit: oh I forgot how Java destroyed the principle behind interfaces by introducing default methods...