Re: multiple inheritance

Arne Vajh??j wrote:


That is true, but "very limited" might be misconstrued as "not very useful".
That Java limits multiple inheritance to interfaces is a design decision of
the language, and confers advantages. These advantages come to the fore when
one follows various recommended practices such as those found in Joshua
Bloch's /Effective Java/.

There are vanishingly few cases where one cannot mix in implementation through
a combination of composition and single inheritance of implementation ('class'
parent types) to accomplish with equal facility what multiple implementation
inheritance would. Avoiding the sorts of downsides mentioned upthread is the
motivation.

There are many times one wishes to guarantee the presence of a contractual
method that is required by several interfaces. 'java.lang.Runnable' need not
be the only interface to specify 'void run();'. Let's say you have a custom
'Raceable' interface that also specifies 'void run();'. There's every reason
to let an algorithm that expects a 'Raceable' to use some concrete type's
'run()' even if it also serves to keep 'Runnable''s promise. Multiple
inheritance of promises is easier to understand and keep bug free.

This ties into a programming approach I call "type-based programming". Given
some concrete type

  public class FormulaOne implements Runnable, Raceable
  {
    @Override
    public void run() { ... }
  }

client code can freely say:

   FormulaOne fone = new FormulaOne();
   Raceable raceable = fone;
   Runnable runnable = fone;

and so forth. Only signatures are shared, so implementation won't be confused.

--
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg