Class versus Interface Inheritance
Class inheritance defines an object's implementation in terms of another object's implementation. In short, it's a mechanism for code and representation sharing.
In contrast, interface inheritance(or subtyping) describes when an object can be used in place of another.
C++ programmers manipulate objects through types defined by abstract classes.
In languages like C++ and Eiffel, inheritance means both interface and implementation inheritance. Although most programming languages don't support the distinction between interface and implementation inheritance, people make the distinction in practice.
Programming to an Interface, not an Implementation
There are two benefits to manipulating objects solely in terms of the interface defined by abstract classes:
1. Clients remain unaware of the specific types of objects they use, as long as the objects adhere to the interface that clients expect.
2. Clients remain unaware of the classes that implement these objects. Clients only know about the abstract class(es) defining the interface.
Putting Reuse Mechanisms to Work
Inheritance versus Composition
visibility: black box VS white-box reuse
payoff: static compile time VS dynamic run-time
inheritance breaks encapsulation
conclusion: Favor object composition over class inheritance.
this is rarely the case, because the set of
available components is never quite rich enough in practice. Reuse by inheritance
makes it easier to make new components that can be composed with old ones.
Inheritance and object composition thus work together.
