Question

I know that multiple inheritance is not allowed in Java and C#. Many books just say, multiple inheritance is not allowed. But it can be implemented by using interfaces. Nothing is discussed about why it is not allowed. Can anybody tell me precisely why it is not allowed?

Answer 1

The short answer is: because the language designers decided not to.

Basically, it seemed that both the .NET and Java designers did not allow multiple inheritance because they reasoned that adding MI added too much complexity to the languages while providing too little benefit.

For a more fun and in-depth read, there are some articles available on the web with interviews of some of the language designers. For example, for .NET, Chris Brumme (who worked at MS on the CLR) has explained the reasons why they decided not to:

1. Different languages actually have different expectations for how MI
   works. For example, how conflicts are
   resolved and whether duplicate bases
   are merged or redundant. Before we can
   implement MI in the CLR, we have to do
   a survey of all the languages, figure
   out the common concepts, and decide
   how to express them in a
   language-neutral manner. We would also
   have to decide whether MI belongs in
   the CLS and what this would mean for
   languages that don’t want this concept
   (presumably VB.NET, for example). Of
   course, that’s the business we are in
   as a common language runtime, but we
   haven’t got around to doing it for MI
   yet.

2. The number of places where MI is truly appropriate is actually quite
   small. In many cases, multiple
   interface inheritance can get the job
   done instead. In other cases, you may
   be able to use encapsulation and
   delegation. If we were to add a
   slightly different construct, like
   mixins, would that actually be more
   powerful?

3. Multiple implementation inheritance injects a lot of complexity into the
   implementation. This complexity
   impacts casting, layout, dispatch,
   field access, serialization, identity
   comparisons, verifiability,
   reflection, generics, and probably
   lots of other places.

You can read the full article here.

For Java, you can read this article:

The reasons for omitting multiple
inheritance from the Java language
mostly stem from the “simple, object
oriented, and familiar” goal. As a
simple language, Java’s creators
wanted a language that most developers
could grasp without extensive
training. To that end, they worked to
make the language as similar to C++ as
possible (familiar) without carrying
over C++’s unnecessary complexity
(simple).

In the designers’ opinion, multiple
inheritance causes more problems and
confusion than it solves. So they cut
multiple inheritance from the language
(just as they cut operator
overloading). The designers’ extensive
C++ experience taught them that
multiple inheritance just wasn’t worth
the headache.