Posted in: J2EE Design Patterns,Java Design Patterns
a practical, proven solution to a recurring design problem
1. Creational
2. Structural
3. Behavioral
Creational patterns are ones that create objects for you, rather than having you instantiate objects directly
Structural patterns help you compose groups of objects into larger structures
Behavioral patterns help you define the communication between objects in your system and how the flow is controlled in a complex program.
Creational Patterns Types
Factory Method : define an interface for creating an object, but let sub-class decide which class to instantiate. This lets a class to defer instantiation to subclasses.
Builder : separate the construction of a complex object from its representation so that the same construction process can create diff. representations.
Abstract Factory : provide an interface for creating families of related or dependent objects without specifying their concrete classes.
Prototype : specify the kinds of objects to create using a prototypical instance and create new objects by copying this prototype.
Singleton : Ensure a class only has one instance, and provide a global point of access to it.
Structural Patterns Types:
Adapter : convert the interface of a class into another interface clients expect. Adapter lets classes work together that could not otherwise because of incompatible interfaces.
The Adapter pattern is used so that two unrelated interfaces can work together. The joining between them is called an Adapter
Bridge : Decouple an abstraction from its implementation so that the two can vary independently.
Composite : compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly
Decorator : Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub classing for extending functionality.
Façade : Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher level interface that makes the subsystem easier to use
Flyweight : use sharing to support large numbers of fine-grained objects efficiently.
Proxy : which provides a simple place-holder class for a more complex class which is expensive to instantiate.
Behavioral Patterns Types:
Chain of responsibility : The responsibility of handling the request data is given to any of the members of the “chain”. If the first link of the chain cannot handle the responsibility, it passes the request data to the next level in the chain, i.e. to the next link. (a chain of classes that process request )
Command : The client invokes a particular module using a command. The client passes a request, this request gets propagated as a command. The command request maps to particular modules. According to the command, a module is invoked. (request encapsulated in an object )
Interpreter : It converts the code written in English to a byte code format so as to make possible for all the operating systems to understand it.
Iterator : which allows you to navigate through a collection of data using a common interface without knowing about the underlying implementation.
Mediator : It promotes loose-coupling of classes such that only one class (Mediator) has the knowledge of all the classes, rest of the classes have their responsibilities and they only interact with the Mediator.
Memento : without violating encapsulation, capture and externalize an objects' internal state so that the object can be restored to this state later. (store and restore object's internal state )
Observer : define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
State : allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
(provides a memory for a class’s instance variables.)
Strategy : Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
(group of classes that represent set of possible behaviors )
Template Method : define the skeleton of an algorithm in an operation, deferring some steps to subclasses. provides a method that allows sub-classes to override parts of method without re-writing it. (provides an abstract definition of an algorithm. )
Visitor : Represent an operation to be performed on the elements of an object structure. Visitor to add new function to a set of classes without having to modify them.