Builder
design pattern
It’s a design
pattern to make complex things. Unlike Strategy design pattern which is
different way to do the same thing, Builder design pattern is same way to build
different things.
It has 4 parts:
1.
Builder
: Abstract class for building objects
2.
Concrete
Builder : Builder’s implementation
3.
Product
: The product that is being built. (Very generic)
4.
Director
/Controller : Builds product with the
help of builders
public class HouseProduct {
private String rawMaterial;
private String foundation;
private String constructionDesc;
public String
getRawMaterial() {
return rawMaterial;
}
public void
setRawMaterial(String rawMaterial) {
this.rawMaterial = rawMaterial;
}
public String
getFoundation() {
return foundation;
}
public void
setFoundation(String foundation) {
this.foundation = foundation;
}
public String
getConstructionDesc() {
return constructionDesc;
}
public void
setConstructionDesc(String constructionDesc) {
this.constructionDesc =
constructionDesc;
}
@Override
public String toString()
{
return "------\n"+rawMaterial+"\n"+foundation+"\n"+constructionDesc+"\n--------\n";
}
}
public interface Builder {
public void
assembleRawMaterial();
public void layFoundation();
public void construct();
public HouseProduct
getProduct();
}
public class TreeHouseBuilder implements Builder {
private HouseProduct product = new HouseProduct();
@Override
public void
assembleRawMaterial() {
product.setRawMaterial("Raw material used :: wood");
}
@Override
public void layFoundation() {
product.setFoundation("Foundation : Tree trunk 20 feet high");
}
@Override
public void construct() {
product.setConstructionDesc("Constructed in 10 days");
}
@Override
public HouseProduct
getProduct() {
return product;
}
}
public class ApartmentBuilder implements Builder {
private HouseProduct product = new HouseProduct();
@Override
public void
assembleRawMaterial() {
product.setRawMaterial("Raw
material used :: concrete & bricks");
}
@Override
public void layFoundation() {
product.setFoundation("Foundation
: 40 feet deep");
}
@Override
public void construct() {
product.setConstructionDesc("Constructed in 1 month");
}
@Override
public HouseProduct
getProduct() {
return product;
}
}
public class ConstructionCompanyDirector {
private Builder builder = null;
public
ConstructionCompanyDirector(Builder builder) {
this.builder = builder;
}
public void constructHouse() {
this.builder.assembleRawMaterial();
this.builder.layFoundation();
this.builder.construct();
}
public HouseProduct
getProduct() {
return this.builder.getProduct();
}
}
public class MainClass {
public static void main(String[]
args) {
ConstructionCompanyDirector
director = new ConstructionCompanyDirector(new
TreeHouseBuilder());
director.constructHouse();
System.out.println(director.getProduct());
ConstructionCompanyDirector
director2 = new ConstructionCompanyDirector(new ApartmentBuilder());
director2.constructHouse();
System.out.println(director2.getProduct());
}
}
Abstract
Factory Design Pattern vs Builder Design Pattern
1.
Abstract
will return the instance directly while in Builder there will be one Director
class which will instruct Builder class to build the different parts/properties
of your object and finally retrieve the object.
2.
Abstract
does not keep the track of it's created object while Builder will have
reference to the created object.
3.
In
builder pattern emphasis is on ‘step by step’.
4.
Builder
pattern is concerned with how a single object is made up by the different
factories, whereas the Abstract Factory pattern is concerned with what products
are made.
5.
The
Builder pattern abstracts the algorithm for construction by including the
concept of a director.
Code link : https://github.com/sksumit1/DesignPatterns
Code link : https://github.com/sksumit1/DesignPatterns
No comments:
Post a Comment