In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.
Design patterns are represented as relationships between classes and objects with defined responsibilities that act in concert to carry out the solution. To illustrate a design pattern, consider the Adapter pattern. Adapter provides a solution to the scenario in which a client and server need to interact with one another, but cannot because their interfaces are incompatible. To implement an Adapter, you create a custom class that honours the interface provided by the server and defines the server operations in terms the client expects. This is a much better solution than altering the client to match the interface of the server.
Why Design Patterns
Design patterns can speed up the development process by providing tested, proven development paradigms. Effective software design requires considering issues that may not become visible until later in the implementation. Reusing design patterns helps to prevent subtle issues that can cause major problems and improves code readability for coders and architects familiar with the patterns.
Often, people only understand how to apply certain software design techniques to certain problems. These techniques are difficult to apply to a broader range of problems. Design patterns provide general solutions, documented in a format that doesn’t require specifics tied to a particular problem.
In addition, patterns allow developers to communicate using well-known, well understood names for software interactions. Common design patterns can be improved over time, making them more robust than ad-hoc designs.
There are three basic classifications of patterns Creational, Structural and Behavioural patterns.
Creational Patterns
Creational design patterns are design patterns that deal with object creation mechanism, 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.
Some examples of creational design patterns include:
Abstract factory pattern: centralize decision of what factory to instantiate
Factory method pattern: centralize creation of an object of a specific type choosing one of several implementations
Builder pattern: separate the construction of a complex object from its representation so that the same construction process can create different representations
Lazy initialization pattern: tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it in needed
Object pool pattern: avoid expensive acquisition and release of resources by recycling objects that are no longer in use
Prototype pattern: used when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects
Singleton pattern: restrict instantiation of a class to one object
Structural pattern
Structural design patterns are design patterns that ease the design by identifying a simple way to realize relationship between entities.
Examples of Structural Patterns include:
Adapter pattern: adapts one interface for a class into one that a client expects
Composite pattern: a tree structure of objects where every object has the same interface
Aggregate pattern: a version of the Composite pattern with the methods for aggregation of children
Decorator pattern: add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes
Façade pattern: create a simplified interface of an existing interface to ease usage for common tasks.
Behavioural pattern
Behavioural design patterns are design patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication.
Examples of this type of design pattern include:
Command pattern: command objects encapsulate an action and its parameters
Interpreter pattern: implement a specialized computer language to rapidly solve a specific set of problems
Iterator pattern: iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation
