Once
a class has been created and tested, it should (ideally) represent a useful
unit of code. It turns out that this reusability is not nearly so easy to
achieve as many would hope; it takes experience and insight to achieve a good
design. But once you have such a design, it begs to be reused. Code reuse is
arguably the greatest leverage that object-oriented programming languages
provide.
The
simplest way to reuse a class is to just use an object of that class directly,
but you can also place an object of that class inside a new class. We call this
“creating a member object.” Your new class can be made up of any
number and type of other objects, whatever is necessary to achieve the
functionality desired in your new class. This concept is called
composition,
since you are composing a new class from existing classes. Sometimes
composition is referred to as a “has-a” relationship, as in
“a car has a trunk.”
Composition
comes with a great deal of flexibility. The
member
objects
of your new class are usually private, making them inaccessible to client
programmers using the class. This allows you to change those members without
disturbing existing client code. You can also change the member objects
at
run time
,
which provides great flexibility. Inheritance, which is described next, does
not have this flexibility since the compiler must place restrictions on classes
created with inheritance.
Because
inheritance is so important in object-oriented programming it is often highly
emphasized, and the new programmer can get the idea that inheritance should be
used everywhere. This can result in awkward and overcomplicated designs.
Instead, you should first look to composition when creating new classes, since
it is simpler and more flexible. If you take this approach, your designs will
stay cleaner. It will be reasonably obvious when you need inheritance.