Factory Method Pattern
The Factory Method pattern is a type of creational pattern. Subclasses decide exactly which class to instantiate in Factory Method. The Factory Method instantiates the appropriate subclass based on information supplied by the client or extracted from the current state.
Singleton pattern ensures that there is only one instance of a class . All the client uses this single instance of a class.
Decorator pattern is used to attach 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.
The Composite pattern 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 Proxy pattern supports objects that control the creation of and access to other objects. The proxy is often object that stands in for a more complex object that is activated once certain circumstances are clear.
The Flyweight pattern promotes an efficient way to share common information present in small objects that occur in a system in large numbers. It thus helps reduce storage requirements when many values are duplicated. The Flyweight pattern distinguishes between the intrinsic and extrinsic state of an object. The greatest savings in the Flyweight pattern occur when objects use both kinds of state but:
• The intrinsic state can be shared on a wide scale, minimizing storage requirements.
• The extrinsic state can be computed on the fly, trading computation for storage.
The Bridge pattern decouples an abstraction from its implementation, enabling them to vary independently. The Bridge pattern is useful when a new version of software is brought out that will replace an existing version, but the older version must still run for its existing client base. The client code will not have to change, as it is conforming to a given abstraction, but the client will need to indicate which version it wants to use.
The Adapter pattern enables a system to use classes whose interfaces don’t quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries.
The Prototype pattern creates new objects by cloning one of a few stored prototypes.It speeds up the instantiation of very large, dynamically loaded classes (when copying objects is faster), and it keeps a record of identifiable parts of a large data structure that can be copied without knowing the subclass from which they were created.
The role of the Façade pattern is to provide different high-level views of subsystems whose details are hidden from users. In general, the operations that might be desirable from a user’s perspective could be made up of different selections of parts of the subsystems.
Abstract Factory Pattern
This pattern creates products that exist in families. The abstract factory can be refined to concrete factories, each of which can create different products of different types and in different combinations. The pattern isolates the product definitions and their class names from the client so that the only way to get one of them is through a factory.
The Builder pattern is used to separate the specifications of a complex object from its actual construction. The same construction process can create different representations.