December 16, 2011 Leave a comment
Construct a complex object from simple objects step by step.
Where to use & benefits
- Make a complex object by specifying only its type and content. The built object is shielded from the details of its construction.
- Want to decouple the process of building a complex object from the parts that make up the object.
- Isolate code for construction and representation.
- Give you finer control over the construction process.
The builder pattern is a creational design pattern used to assemble complex objects. With the builder pattern, the same object construction process can be used to create different objects. The builder has 4 main parts: a Builder, Concrete Builders, a Director, and a Product.
A Builder is an interface (or abstract class) that is implemented (or extended) by Concrete Builders. The Builder interface sets forth the actions (methods) involved in assembling a Product object. It also has a method for retrieving the Product object (ie, getProduct()). The Product object is the object that gets assembled in the builder pattern.
Concrete Builders implement the Builder interface (or extend the Builder abstract class). A Concrete Builder is responsible for creating and assembling a Product object. Different Concrete Builders create and assemble Product objects differently.
A Director object is responsible for constructing a Product. It does this via the Builder interface to a Concrete Builder. It constructs a Product via the various Builder methods.
There are various uses of the builder pattern. For one, if we’d like the construction process to remain the same but we’d like to create a different type of Product, we can create a new Concrete Builder and pass this to the same Director. If we’d like to alter the construction process, we can modify the Director to use a different construction process.