programming-for-dummies

240
Sharing Code with Inheritance
Single vs. multiple inheritance
When one object inherits everything from
another object, that’s single inheritance. Some
programming languages, such as C++, also can
allow objects to inherit from two or more
objects, which is multiple inheritance:
Good news: Multiple inheritance can use
the best parts from two or more objects
and smash them together to create a new
object.
Without multiple inheritance, you can only
inherit code from one object and then you
must duplicate code from a second object.
Because duplicating code is what objectoriented
programming tries to avoid in the
first place, multiple inheritance is yet
another way to make creating objects easy
and fast by reusing existing code from
other objects.
Bad news: Multiple inheritance can make
programs harder to understand.
By inheriting parts from so many objects, an
object can become a hodge-podge collection
of parts from everywhere. So a single
object that inherits code from multiple
objects is not only harder to understand, but
also dependent on too many other parts of
a program. Such interdependency of code
is a problem object-oriented programming
tries to eliminate in the first place.
If your programming language offers multiple
inheritance, try it to see if its benefits outweigh
its drawbacks. If your programming language
doesn’t offer multiple inheritance, don’t feel that
you’re missing out on anything because most
programming languages don’t offer multiple
inheritance.
Sound like a lot of trouble? It is, which is what makes inheritance so attractive.
With inheritance, you don’t make multiple, physical copies of subprograms.
Instead, you first store the subprogram in an object (a class file).
Next, you inherit that object. Inheritance tells the computer to copy an
object (along with all the subprograms stored inside that object) and store
all the data and subprograms from that first object into that second object.
Physically, this second object contains no code of its own. Instead, the
second object points to the code of the original object, as shown in Figure 7-7.
When you run subprograms in this second object, this second object tells
the computer, “Hey, those subprograms are really stored in this other object
that I inherited them from.”
Inheritance offers two advantages:
✦ Because it doesn’t make multiple copies of the same subprograms,
inheritance saves space.
✦ Because only one copy of a subprogram physically exists, inheritance
makes it easy to update a subprogram.