* AbstractClass * implements a template method defining the skeleton of an algorithm */

* Abstract Expression * declares an abstract Interpret operation that is common to all nodes * in the abstract syntax tree */

* Abstract Factory * provides an abstract interface for creating a family of products */

* Abstraction * defines the abstraction's interface */

* Adaptee * defines an existing interface that needs adapting and thanks * to Adapter it will get calls that client makes on the Target * */

* Adaptee * all requests get delegated to the Adaptee which defines * an existing interface that needs adapting */

* Adapter * implements the Target interface and when it gets a method call it * delegates the call to a Adaptee */

* Adapter * implements the Target interface and lets the Adaptee respond * to request on a Target by extending both classes * ie adapts the interfa

* Aggregate * defines an interface for aggregates and it decouples your * client from the implementation of your collection of objects */

* Builder * abstract interface for creating products */

* CareTaker * is responsible for the memento's safe keeping */

* Client * creates a new object by asking a prototype to clone itself */

* Colleague classes * each colleague communicates with its mediator whenever * it would have otherwise communicated with another colleague */

* Command * declares an interface for all commands */

* Component * defines an interface for objects that can have responsibilities * added to them dynamically */

* Component * defines an interface for all objects in the composition * both the composite and the leaf nodes */

* Composite * defines behavior of the components having children * and store child components */

* Concrete Builder X and Y * create real products and stores them in the composite structure */

* Concrete Class * implements the primitive operations to carry out specific steps * of the algorithm, there may be many Concrete classes, each impl

* Concrete Command * implements execute by invoking the corresponding * operation(s) on Receiver */

* Concrete Component * defines an object to which additional responsibilities * can be attached */

* Concrete Creator * implements factory method that is responsible for creating * one or more concrete products ie. it is class that has * the know

* Concrete Decorators * add responsibilities to the component (can extend the state * of the component) */

* Concrete Factory X and Y * each concrete factory create a family of products and client uses * one of these factories so it never has to instantia

* ConcreteFlyweight * implements the Flyweight interface and adds storage * for intrinsic state */

* Concrete Handlers * handle requests they are responsible for */

* Concrete Implementors * implement the Implementor interface and define concrete implementations */

* Concrete Iterator * implements the interface and is responsible for managing * the current position of the iterator */

* Concrete Mediator * implements cooperative behavior by coordinating Colleague objects * and knows its colleagues */

* Concrete Observer * stores state of interest to ConcreteObserver objects and * sends a notification to its observers when its state changes */

* Concrete Product * define product to be created */

* ConcreteProductAX and ConcreteProductAY * define objects to be created by concrete factory */

* Concrete Product * define product to be created */

* ConcreteProductBX and ConcreteProductBY * same as previous concrete product classes */

* Concrete Prototype A and B * implement an operation for cloning itself */

* Concrete States * each subclass implements a behavior associated with a state * of the Context */

* Concrete Strategies * implement the algorithm using the Strategy interface */

* Concrete Subject * stores state that should stay consistent with the subject's */

* Concrete Visitors * implement each operation declared by Visitor, which implement * a fragment of the algorithm defined for the corresponding clas

* Context * maintains a reference to a Strategy object */

* Context * contains information that's global to the interpreter */

* Context * defines the interface of interest to clients */

* Creator * contains the implementation for all of the methods * to manipulate products except for the factory method */

* Decorator * maintains a reference to a Component object and defines an interface * that conforms to Component's interface */

* Director * responsible for managing the correct sequence of object creation */

* Facade * delegates client requests to appropriate subsystem object * and unified interface that is easier to use */

* Flyweight * declares an interface through which flyweights can receive * and act on extrinsic state */

* FlyweightFactory * creates and manages flyweight objects and ensures * that flyweights are shared properly */

* Handler * defines an interface for handling requests and * optionally implements the successor link */

* Implementor * defines the interface for implementation classes */

* Invoker * asks the command to carry out the request */

* Leaf * defines the behavior for the elements in the composition, * it has no children */

* Memento * stores internal state of the Originator object and protects * against access by objects other than the originator */

* Nonterminal Expression * implements an Interpret operation for nonterminal symbols * in the grammar (one such class is required for every rule in

* Observer * defines an updating interface for objects that should be notified * of changes in a subject */

* Originator * creates a memento containing a snapshot of its current internal * state and uses the memento to restore its internal state */

* Product * products implement the same interface so that the classes can refer * to the interface not the concrete product */

* Product * the final object that will be created using Builder */

* Product A * products implement the same interface so that the classes can refer * to the interface not the concrete product */

* Product B * same as Product A, Product B declares interface for concrete products * where each can produce an entire set of products */

* Prototype * declares an interface for cloning itself */

* Proxy * maintains a reference that lets the proxy access the real subject */

* Real Subject * defines the real object that the proxy represents */

* Receiver * knows how to perform the operations associated * with carrying out a request */

* RefinedAbstraction * extends the interface defined by Abstraction */

* Singleton * has private static variable to hold one instance of the class * and method which gives us a way to instantiate the class */

* State * defines an interface for encapsulating the behavior associated * with a particular state of the Context */

* Strategy * declares an interface common to all supported algorithms */

* Subject * defines the common interface for RealSubject and Proxy * so that a Proxy can be used anywhere a RealSubject is expected */

* Subsystems * implement more complex subsystem functionality * and have no knowledge of the facade */

* Target * defines specific interface that Client uses */

* Target * defines specific interface that Client uses */

* Terminal Expression * implements an Interpret operation associated with terminal symbols * in the grammar (an instance is required for every termi

* UnsharedConcreteFlyweight * not all subclasses need to be shared */

* Visitor * declares a Visit operation for each class of ConcreteElement * in the object structure */