nerd@metrocat.org

Simon, Java and C# don’t support Multiple Inheritance at all. Instead they support single inheritance and interfaces.

Inheritance in the Object Oriented world is a form of code re-use. Take a quick glance at Inheritance (object oriented programming), Wikipedia. On the other hand, Interfaces are a promise to support the same behaviour. Also see Interface (computer science), Wikipedia, without the baggage of a particular implementation.

C++ supports Multiple Inheritance but doesn’t really support Interfaces. We mimic them using a class having only pure-virtual functions and no member variables. In contrast, Java and C# support Interfaces but don’t support Multiple Inheritance.

Objective-C supports Interfaces but not Multiple Inheritance, but it also supports the ability to dynamically extend any class using Categories. You can also completely replace method implementations using Categories. It’s very cool.

Javascript actually supports a limited form of Multiple Inheritance. Inside a constructor, if you call another constructor function the new object will inherit any properties and methods defined in that constructor. However, the new object will not inherit methods defined in the second constructor’s prototype chain. For example:

function FirstConstructor( name )
{
    this.name=name;
}
FirstConstructor.prototype.getName= function()
{
    return this.name;
}

function SecondConstructor( size )
{
    this.size=size;
    this.inflate= function()
        {
            this.size++;
        }
}
SecondConstructor.prototype.deflate= function()
{
    this.size--;
}

function TestMultipleInheritance( name, size )
{
    FirstConstructor.call( this, name );
    SecondConstructor.call( this, size );
}
TestMultipleInheritance.prototype= new FirstConstructor;

Any instances of TestMultipleInheritance will possess properties for name and size. In addition, each TestMultipleInheritance object will have a unique copy of the inflate method (because it was allocated in the constructor), and will inherit via the prototype chain the getName method of FirstConstructor.

You’ll only ever be able to tell that a TestMultipleInheritance object is also a FirstConstructor object using the instanceof operator. Without additional hackery, there’s no way to tell whether objects are also SecondConstructor objects. And in fact, TestMultipleInheritance objects aren’t entirely SecondConstructor objects because they are lacking the deflate method.

I know this is a contrived example, but I think it illustrates the point. I’ve never actually needed to use Multiple Inheritance in Javascript, and Javascript doesn’t support Interfaces.

I’m not certain you can actually mimic Multiple Inheritance, because the inheritance aspect is the key to the whole thing. With Interfaces you are promising to support the same methods (and something like the same behaviour), but you have to do all the work yourself.

With Multiple Inheritance there’s no need to promise, the object does support the same methods and you get the implementation for free.

I doubt if anyone has a really good reason to do even the slightly crippled Multiple Inheritance from my example. I know I’ve never needed it in almost a decade of writing Javascript.