Why is Multiple Inheritance not allowed in Java or C#?

by

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.

More Related Contents:

  1. Why aren’t variables declared in “try” in scope in “catch” or “finally”?
  2. Difference between Equals/equals and == operator?
  3. Why are C# 3.0 object initializer constructor parentheses optional?
  4. Pre & post increment operator behavior in C, C++, Java, & C# [duplicate]
  5. C++ performance vs. Java/C#
  6. Best practices for exception management in Java or C# [closed]
  7. What are the differences between Generics in C# and Java… and Templates in C++? [closed]
  8. Is shifting bits faster than multiplying and dividing in Java? .NET? [closed]
  9. Why can’t I have abstract static methods in C#?
  10. How would you code an efficient Circular Buffer in Java or C#?
  11. What does void mean in C, C++, and C#?
  12. Why aren’t C# static class extension methods supported?
  13. Why is The Iteration Variable in a C# foreach statement read-only?
  14. Why are private fields private to the type, not the instance?
  15. Why do local variables require initialization, but fields do not?
  16. Where can I find a Java to C# converter? [closed]
  17. Why must we define both == and != in C#?
  18. Why are const parameters not allowed in C#?
  19. Difference between namespace in C# and package in Java
  20. How to read a .NET Guid into a Java UUID
  21. Why should casting be avoided? [closed]
  22. Why is “null” present in C# and Java?
  23. Why is adding null to a string legal?
  24. Stroke Width Transform (SWT) implementation (Java, C#…) [closed]
  25. Why can’t I retrieve an item from a HashSet without enumeration?
  26. Why must C# operator overloads be static?
  27. Basic render 3D perspective projection onto 2D screen with camera (without opengl)
  28. Calling an overridden method from a parent class ctor
  29. Why value-types are stored onto Stacks?
  30. How does Java’s use-site variance compare to C#’s declaration site variance?

Leave a Comment