Decorator
- Attach additional responsibilities to an object dynamically.
- Decorators provide a flexible alternative to subclassing for extending
functionality.

- Component : defines the interface for objects
that can have responsibilities added to them dynamically.
- Decorator : maintains a reference to a
Component object and defines an interface that conforms to Component's
interface.
- ConcreteDecorator :
adds responsibilities to the component.
- to add responsibilities to individual objects dynamically and
transparently, that is, without affecting other objects.
- for responsibilities that can be withdrawn.
- when extension by subclassing is impractical. Sometimes a large number of
independent extensions are possible and would produce an explosion of
subclasses to support every combination. Or a class definition may be hidden
or otherwise unavailable for subclassing.
- More flexibility than static inheritance. The Decorator pattern
provides a more flexible way to add responsibilities to objects than can be
had with static (multiple) inheritance. With decorators responsibilities can
be added and removed at run-time simply by attaching and detaching them.
- Avoids feature-laden classes high up in the hierarchy. Decorator
offers a pay-as-you-go approach to adding responsibilities. Instead of
trying to support all foreseeable features in a complex, customizable class,
you can define a simple class and add functionality incrementally with
Decorator objects. Functionality can be composed from simple pieces. As a
result, an application needn't pay for features it doesn't use.
- A decorator and its component aren't identical. A decorator acts as
a transparent enclosure. But from an object identity point of view, a
decorated component is not identical to the component itself. Hence you
shouldn't rely on object identity when you use decorators.
- Lots of little objects. A design that uses Decorator often results
in systems composed of lots of little objects that all look alike. The
objects differ only in the way they are interconnected, not in their class
or in the value of their variables. Although these systems are easy to
customize by those who understand them, they can be hard to learn and debug.