Proxies are front ends to classes that have sensitive data or slow operations. Proxies, like decorators, forward
requests on to another object - the difference is that the proxy relationship is set up at design time and is well
known in advance, even though the original class is not an active participator in the relationship. Decorators, on
the other hand, can be added dynamically.
Decouples an abstraction from its implementation, enabling
them to vary independently. This pattern is useful, for
example, when a new version of software is released that will
replace an existing version but the older version must still run
for existing clients.
Provide a way of attaching new state and behavior to an object dynamically. The object does not know it
is being decorated, which makes this a useful pattern for evolving systems. A key implementation point is
that decorators both inherit the original class (or implement an interface in common with the original class)
and contain an instantiation of it.
Important point: this pattern is based around new objects being created with their own set of operations.
Arranges structured hierarchies so that single components
and groups of components can be treated in the same way.
Typical operations on the components include add, remove, display, find and group.
The Composite pattern looks like an ordinary data structure implementation, but it is more than that because of its ability to
manipulate the different types of the elements equally.
Used in conjunction with the Decorator, Iterator and Visitor patterns
Promotes an efficient way to share common information present in small objects that occur in a system in larger
numbers. It helps to reduce storage requirements when many
values are duplicated.
Enables a system to use classes whose interfaces don't quite
match its requirements. The important contribution of this
pattern is that it promotes programming to interfaces. Two
Object adapter: aggregate the adaptee, adding behavior to it
Class adapter: implements an interface and inherits a class, overriding adaptee behavior.
Provide different high-level views of subsystems whose details are hidden from users. In general, the operations that
might be desirable from a users perspective could be made up of different selections of parts of the subsystem.