"A Design Pattern is a general repeatable solution to a commonly occurring problem in software design"
In other words we can say: Design Pattern is not a finished design that can be transformed directly into code but It is a description or template for how to solve a problem that can be used in many different situations.
Design patterns help you choose design alternatives that make a system reusable and avoid alternatives that compromise re-usability.
There are three basic kinds of design patterns:
Structural patterns generally deal with relationships between entities, making it easier for these entities to work together.
Creational Design Patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational Design Patterns solve this problem by somehow controlling this object creation.
Behavioral patterns are used in communications between entities and make it easier and more flexible for these entities to communicate.
Creates an instance of several families of classes
Separates object construction from its representation
Creates an instance of several derived classes
A fully initialized instance to be copied or cloned
A class of which only a single instance can exist
Match interfaces of different classes
Separates an object’s interface from its implementation
A tree structure of simple and composite objects
Add responsibilities to objects dynamically
A single class that represents an entire subsystem
A fine-grained instance used for efficient sharing
An object representing another object
A way of passing a request between a chain of objects
Encapsulate a command request as an object
A way to include language elements in a program
Sequentially access the elements of a collection
Defines simplified communication between classes
Capture and restore an object's internal state
A way of notifying change to a number of classes
Alter an object's behavior when its state changes
Encapsulates an algorithm inside a class
Defer the exact steps of an algorithm to a subclass
Defines a new operation to a class without change