Multiple Inheritance

Multiple Inheritance

Traditional (C++-like) implementation of multiple inheritance has several
issues:
the diamond problem,

Michal P´se (CTU in Prague)
ıˇ Object Programming Lect. 5: Multiple Inheritance October 26, 2010 2 / 11


issues:
name clashes,



issues:
name clashes,
glue code and



issues:
name clashes,
glue code and
initialization order.


The Diamond Problem

class Foo {...}
class Bar extends Foo {...}
class Baz extends Foo {...}
class Qux extends Bar, Baz {...}

How many instances of Foo should be in one instance of Qux?


Name Clashes

class Foo { void bar() {...} }
class Baz { void bar() {...} }
class Qux extends Foo, Baz {...}

Which of the two methods named bar gets called during execution of
new Qux().bar()?


Name Clashes


new Qux().bar()?
What if we need to keep both implementations of bar?


Name Clashes


new Qux().bar()?
What if we need to keep both implementations of bar?
Is it even type-safe to discard one of bar implementations? What
about the Liskov substitution principle?


Glue Code

class Foo { class Qux {
void bar() { baz(); } void corge() {...}
abstract void baz(); }
}

class Grault extends Foo, Qux {
void baz() { corge(); }
}

Grault.baz exists only to connect Foo.baz and Qux.corge.
In a simpliﬁed way, glue code can be thought of as an opposite problem to
name clashes.


Initialization Order

In which order should we dispatch parent constructors when there are
circular dependencies?


The Need for Multiple Inheritance

Do we even need multiple inheritance? Is it worth the trouble?
Yes.



Yes.
Units of reuse are smaller than units of instantiation. To
compose a class, many smaller reusable chunks of code need to be
composed together.



Yes.
Units of reuse are smaller than units of instantiation. To
compose a class, many smaller reusable chunks of code need to be
composed together.
The alternative is code duplication.


Traits

A recent multiple inheritance model.

When inheriting, traits allow to
create method aliases (to partially resolve name clashes and name
mismatches),


Traits


mismatches),
drop methods (to get rid of unwanted functionality or to avoid the
diamond problem) and


Traits


mismatches),
drop methods (to get rid of unwanted functionality or to avoid the
diamond problem) and
break the Liskov substitution principle (they do not imply
subtyping and therefore subsumption is not an issue).


Eiﬀel’s Multiple Inheritance

Eiﬀel approach:
allow method renaming (name clashes can be resolved while
sticking to the Liskov substitution principle) and


Eiﬀel’s Multiple Inheritance

Eiﬀel approach:
allow method renaming (name clashes can be resolved while
sticking to the Liskov substitution principle) and
utilize static type information to keep track of method renaming.


CZ (Cubic Zirconia)

Two kinds of inheritance hierarchies: extends and requires.


CZ (Cubic Zirconia)

Extends hierarchy can not contain cycles.


CZ (Cubic Zirconia)

Extends hierarchy can not contain cycles.
Initialization is based on extends hierarchy.


See

St´phane Ducasse, Oscar Nierstrasz, Nathanael Sch¨rli, Roel Wuyts, and
e a
Andrew P. Black. Traits: A mechanism for ﬁne-grained reuse. ACM
Transanctions on Programming Languages and Systems 28, 2 (March
2006), 331–388. http://doi.acm.org/10.1145/1119479.1119483
Donna Malayeri and Jonathan Aldrich. CZ: multiple inheritance
without diamonds. In Proceeding of the 24th ACM SIGPLAN conference
on Object oriented programming systems languages and applications
(OOPSLA ’09). 21–40.
http://doi.acm.org/10.1145/1640089.1640092


Multiple Inheritance

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (16)

Similar to Multiple Inheritance

Similar to Multiple Inheritance (20)

Multiple Inheritance