nerd

5 Comments

1. Simon
   Posted 27 Aug 2005 at 5:42 am | Permalink

   What exactly is wrong about the statement about interfaces? I’d say they certainly play a large role in multiple-inheritance structures in Java.

2. Jeff Watkins
   Posted 27 Aug 2005 at 8:18 am | Permalink

   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.

3. Simon
   Posted 27 Aug 2005 at 9:04 am | Permalink

   ah, ok now I understand your point – The author of the article shoudn’t have said “most modern languages (c#, java) implement this” since they don’t implement it. I immediately read ‘implement’ as ‘mimic’ I think.

   The author would have been correct in saying that the way c# and java mimic multiple inheritance is by using interfaces (and delegation of course), wouldn’t he?

   Thanks for the javascript example – I doubt I’ll ever need it but it’s always good to learn something. :-)

4. Jeff Watkins
   Posted 27 Aug 2005 at 8:08 pm | Permalink

   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.

5. Paul C
   Posted 10 Jan 2007 at 12:47 pm | Permalink

   um.. you CAN mimic multiple inheritance in Java.

   interface Cat { void meow(); }

   class CatImpl implements Cat { public void meow(){} }

   interface Dog { void bark(); }

   class DogImpl implements Dog { public void bark(){};

   class DogCat extends CatImpl implements Dog { private Dog dog = new DogImpl();

   public void meow() { super.meow(); //I know this isn’t necessary..for clarity

   public void bark(){ dog.bark(); } }

   In what way is this NOT multiple inheritance? And you can see with this example why MI can be a bad thing…Exactly what is a DogCat?