Interface Inheritance versus Implementation Inheritance
In the first case, we are referring to a class inheriting
from an interface (or in VB terms, implementing the interface). In the second
case, we mean a class inheriting from a super-class.
Classes having knowledge of other classes
When one class knows about another class, it simply means
that it holds a reference to the other class and its methods and properties.
Let us look at it from another angle. When coding a class
which knows another class, you have to know exactly which class it will need to
use, the name of the class, etc. You may also need to know its internal
workings. Obviously, it translates into higher coupling since a change to the
referred class can mean a change the referee class.
When a class interacts with, accesses and/or modifies
another class through a wide interface, it means that it has intimacy with that
other class. It means that the "interactor" has wide knowledge of
the "interactee" and is able to get its work done through that wide
knowledge. A wide interface means that the class knows all the methods and
member variables which are available in order to manipulate them intimately. We
see this type of interaction between director and concrete-builder in the
Obviously, this not only breaks encapsulation, but it also
greatly increases coupling. It is somewhat similar to the wife who knows every
little detail about the husband and how he thinks. She knows just the right
words to say and the little looks to drop to get him to do something. She is
interacting through a wide interface since she can reach across a wide set of
psychological handles that affect his behaviour and the action she desires. She
knows the exact way to angle her face, remove a lock of hair and crease her
lips to stimulate just the right part of the man’s psyche into action. I do
not say this is a bad thing; in fact, it is very necessary. Men are lazy and
need pushing and prodding. It is simply an example of a wide interface.
Interaction through a wide interface makes for stability in
marriage since a wife and husband are the hardest people to replace, their
interactions being so complex, multi-faceted and fine-tuned. In the average
circumstances, it gives children a stable environment in which to grow up and
enjoy the input of both parties in their development. So in fact, society
benefits from the fact that wives interact with their husbands through wide
A narrow interface is the interface through which most
classes would normally interact with another class. It normally consists of
the interaction with properties and methods in a way that assumes a minimum of
knowledge about the class, possibly just a single method name to invoke.
Aggregation versus acquaintance
Do not fall into the trap that I did when I confused
aggregation with the use of a data-structure which contains several references to
the aggregatee. Aggregation has nothing to do with numbers and may involve one
aggregatee or many. So it may in fact be through a data-structure, but more
times than not through a single object reference.
So what is it? Aggregation means that the aggregator and
aggregatee are bound in such a way that the useful object lifetime of the
aggregatee is also the useful lifetime of the aggregator. For as long as the
aggregator has useful work to do, it needs the aggregatee to do so.
So think object lifetime and not numbers. Due to the link
between their useful lifetimes, it becomes useful for the aggregator’s
constructor method to include the instantiation of a new aggregatee-helper
class at the same time. The destructor of the helper class is also tied to
that of the main class.
For on-line browsing the web-browser needs to have a
reference to a live internet connection and so the browser aggregates the
internet-connection. Therefore we see the aggregator/aggregatee principle in
the web browsers’ connection settings where the activation of the browser can
be tied to the activation of the connection in the settings below.
Listing 1: Internet Options showing aggregator
Launching Internet explorer (in the absence of a network
internet connection) automatically brings up the following.
Listing 2: Web browser instantiating a connection
Similarly, when there is no web browser to send useful work
through the internet connection, there is no point in keeping it alive and we
can configure dial-up connections to reflect this with the following dialog. We
configure the connection to be disposed of with the browser by setting the
number of minutes we should allow the connection to be idle before
Listing 3: Disposing connections when the browser
In the Builder pattern we can see a director as the
aggregator and the concrete-builder as the aggregatee.
Acquaintanceship is when there is a reference to an
acquaintance class. However, the usefulness of the main class is not tied to
the usefulness of the acquaintance. It used to be that someone’s heart
dictated the number of years they could live. If your ticker gave up, you were
forced to do the same. Thankfully, this is not so anymore. Your heart is now a
helper object, not the main object. You are the one with the relationship to
your kids, spouse, co-workers, community, clubs, country and God. Your heart
is here to help you to keep on living; you are not here to live just because
your heart decides to continue beating.
Medical science recognizes this and has made dramatic and
far reaching progress in cardiac medicine. We have valve replacement,
bypasses, pace-makers and, in the most extreme circumstances, heart
transplants. All these techniques mean that you now have an (albeit very
strong) acquaintance with your heart. Their lifetimes are no longer
inextricably linked in an aggregator/aggregatee relationship.
Acquaintance is more typical in the bridge pattern.
In the creational patterns, factory classes perform
instantiation services (return new product classes) on behalf of client code. They
make the decision about which class should be instantiated based on the needs
communicated by the client code. This allows clients to focus on the main work
they are supposed to perform without worrying about how to procure the
tool-classes they need. In the same way you do not want to go to work everyday
and worry about how they supply drinking water, clean air and office supplies
at your office, the factory classes free and decouple the main classes from the
tedium of instantiating other classes.
The classes which are instantiated by factory classes and
returned to the client are called product-classes. They are usually returned
not as an instance of the class they are defined as, but as the interface they
implement. This ensures that they are interchangeable and, regardless of the
actual product class returned, it works seamlessly with the client.