Builder
Design Pattern in Java
Intent
Separate
the construction of a complex object from its representation so that the same
construction process can create different representations.
Motivation
As an application grows complex,
the complexity of the classes and objects used also increases. Complex objects
are constructed by using other objects and needs special handling when being
constructed.
An application might need a
mechanism for building complex objects that is independent from the ones that
make up the object. In this scenario, one might want to try using the Builder
design pattern.
Builder pattern allows a client
object to construct a complex object by specifying only its type and content,
being shielded from the details related to the object’s representation. This way the construction
process can be used to create different representations. The logic of this
process is isolated form the actual steps used in creating the complex object,
so the process can be used again to create a different object form the same set
of simple objects as the first one.
Applicability
Use
the Builder pattern when
·
The algorithm for creating a complex
object should be independent of the parts that make up the object and how
they're assembled.
·
The construction process must allow
different representations for the object that's constructed.
Consequences
·
Builder pattern
lets you vary a product's internal representation. The Builder object provides
the director with an abstract interface for constructing the product. The interface
lets the builder hide the representation and internal structure of the product.
It also hides how the product gets assembled.
·
Builder pattern
isolates code for construction and representation. The Builder pattern improves
modularity by encapsulating the way a complex object is constructed and
represented.
·
Builder pattern
gives you finer control over the construction process.
Implementation
We
will implement Builder Pattern by using following classes.
1.
Our first class
would be Meal class, which represents food items in a meal. It represents a
drink, main course, and side.
|
public class Meal {
private String drink;
private String mainCourse;
private String side;
public String
getDrink() {
return drink;
}
public void setDrink(String
drink) {
this.drink = drink;
}
public String
getMainCourse() {
return mainCourse;
}
public void
setMainCourse(String mainCourse) {
this.mainCourse = mainCourse;
}
public String getSide() {
return side;
}
public void setSide(String
side) {
this.side = side;
}
public String
toString() {
return "Drink
: " + drink + ", Main Course : " + mainCourse + ", Side
Dish : " + side;
}
}
|
2.
Here we create a
Builder interface, MealBuilder. It methods will be used to build a meal and to
retrieve the meal.
|
public interface MealBuilder {
public void buildDrink();
public void
buildMainCourse();
public void buildSide();
public Meal
getMeal();
}
|
3.
Our first implementation
of MealBuilder is ItalianMealBuilder. Its constructor creates a meal. Its
methods are implemented to build the various parts of the meal. It returns the
meal using getMeal() method.
|
public class
ItalianMealBuilder implements MealBuilder {
private Meal meal;
public
ItalianMealBuilder() {
meal = new Meal();
}
@Override
public void buildDrink()
{
meal.setDrink("Martini");
}
@Override
public void
buildMainCourse() {
meal.setMainCourse("Simple
Spinach Lasagna");
}
@Override
public void buildSide() {
meal.setSide("Spring
Green Risotto");
}
@Override
public Meal
getMeal() {
return meal;
}
}
|
4.
Similarly second
implementation of MealBuilder is JapaneseMealBuilder. Its constructor creates a
meal. Its methods are implemented to build the various parts of the meal. It
returns the meal using getMeal() method.
|
public class
JapaneseMealBuilder implements MealBuilder{
private Meal meal;
public
JapaneseMealBuilder() {
meal = new Meal();
}
@Override
public void buildDrink()
{
meal.setDrink("Chuhai");
}
@Override
public void
buildMainCourse() {
meal.setMainCourse("Tofu
and Sweet Potato");
}
@Override
public void buildSide() {
meal.setSide("Onigiri");
}
@Override
public Meal
getMeal() {
return meal;
}
}
|
5.
The MealDirector
class takes a MealBuilder as a parameter in its constructor. A different type
of meal will be assembled by the MealDirector depending on the Concrete Builder
passed in to the constructor.
|
public class MealDirector {
private MealBuilder
mealBuilder = null;
public
MealDirector(MealBuilder mealBuilder) {
this.mealBuilder
= mealBuilder;
}
public void
constructMeal() {
mealBuilder.buildDrink();
mealBuilder.buildMainCourse();
mealBuilder.buildSide();
}
public Meal getMeal()
{
return
mealBuilder.getMeal();
}
}
|
6.
The Main class is
used as entry point to the application and demonstrate our builder pattern code.
|
public class Main {
public static void main(String[]
args) {
MealBuilder mealBuilder = new
ItalianMealBuilder();
MealDirector mealDirector = new MealDirector(mealBuilder);
mealDirector.constructMeal();
Meal meal = mealDirector.getMeal();
System.out.println("Italian
Meal : " + meal);
mealBuilder = new
JapaneseMealBuilder();
mealDirector = new MealDirector(mealBuilder);
mealDirector.constructMeal();
meal = mealDirector.getMeal();
System.out.println("Japanese
Meal : " + meal);
}
}
|
When
we execute the Main class we get the following output
 |
Builder
Design Pattern in Java
|
