Behavioral patterns help you define a structure for inter-object
communication between objects in your system. This design pattern is typically
used to monitor the messages that are transmitted when the objects communicate
in a system. The following are the sub patterns under Behavioral Patterns.
Chain of Responsibility
The Chain of Responsibility Pattern is one that details a way
of passing a request between a chain of objects. The Command Pattern encapsulates
a command request as an object. The Interpreter Pattern is a way to include
language elements in a program. The Iterator Pattern sequentially accesses the
elements of a collection. The Mediator Pattern defines simplified
communication between classes. The Memento Pattern captures and restores an
object's internal state. The Observer Pattern is a design pattern that
provides a way of notifying a change to a number of its dependant classes. Therefore,
when one object changes its state, so do all its dependant objects in the sub
system. The State Pattern is a design pattern that changes an object's
behavior when the internal state of the object changes. The Strategy Pattern
is used to encapsulate a family of algorithms inside a class and use them
interchangeably and independent of the client application that use the same. The
Template Method Pattern is a design pattern that is used to provide a template
of an algorithm and defers some of the steps of the algorithm to the subclasses.
The Visitor Pattern is one that is used to define a new operation to a class
without a change.