Software design: Lecture 33 - Sheraz Pervaiz

1

Software Design
Lecture : 33


2

Builder Design Pattern


3

Motivation for Builder Design 
Pattern
 In  general,  object  construction  details  such  as 
instantiating  and  initializing  the  components  that  make 
up the object are kept within the object, often as part of 
its constructor.

 This  type  of  design  closely  ties  the  object  construction 
process with the components that make up the object.


4

Motivation Continue…
 This  approach  is  suitable  as  long  as  the  object  under 
construction is simple and the object construction process 
is  definite  and  always  produces  the  same  representation 
of the object.

5

Motivation
 This design may not be effective when the object being created 
is  complex  and  the  series  of  steps  constituting  the  object 
creation  process  can  be  implemented  in  different  ways 
producing different representations of the object. 
 Different  implementations  of  the  construction  process  are  all 
kept  within  the  object,  the  object  can  become  bulky 
(construction bloat) and less modular. Subsequently, adding a 
new  implementation  or  making  changes  to  an  existing 
implementation requires changes to the existing code.


6

Intent of Builder Design Pattern
Separate  the  construction  of  a  complex  object 
from  its  representation  so  that  the  same 
construction 

process 

different representations.

can 

create 

7

Builder Pattern
 Using the Builder pattern, the process of constructing such an 
object can be designed more effectively. 

 The Builder pattern suggests moving the construction logic out 
of the object class to a separate class referred to as 
    a builder class.

 There  can  be  more  than  one  such  builder  class  each  with 
different  implementation  for  the  series  of  steps  to  construct 
the object.


8

Builder Pattern
 Each  such  builder  implementation  results  in  a  different 
representation of the object. 

 This type of separation reduces the object size.

 The object construction process becomes independent of 
the  components  that  make  up  the  object.  This  provides 
more control over the object construction process.

9

Class Diagram
In terms of implementation, each of the different 
steps in the construction process can be declared 
as  methods  of  a  common  interface  to  be 
implemented  by  different  concrete  builders  as 
shown in the class diagram in next slide


10


11

Sequence Diagram


12

Flow in Existing Logic
This  approach  requires  every  client  object  to  be 
aware of the construction logic.

Whenever  the  construction  logic  undergoes  a 
change,  all  client  objects  need  to  be  modified 
accordingly.


13

Solution in Builder Design Pattern
Instead  of  having  client  objects  invoke  different 
builder  methods  directly,  the  Builder  pattern 
suggests using a dedicated object referred to as a 
Director,  which  is  responsible  for  invoking 
different  builder  methods  required  for  the 
construction of the final object


14

Builder Design Pattern
Different  client  objects  can  make  use  of  the 
Director object to create the required object and 
once  the  object  is  constructed,  the  client  object 
can directly request from the builder the fully
   constructed object.


15

Builder Design Pattern
A  new  method  getObject  can  be  declared  in  the 
common Builder interface to be implemented by 
different concrete builders.


16

Improvements in Previous Design
The  new  design  eliminates  the  need  for  a  client 
object  to  deal  with  the  methods  constituting  the 
object construction process and encapsulates the 
details of how the object is constructed from the 
client.


17

Class Diagram of Improved Version


18


19

Interaction Flow
i.

The  client  object  creates  instances  of  an  appropriate 
concrete  Builder  implementer  and  the  Director.  The  client 
may use a factory for creating an appropriate Builder object.

ii.

  The  client  associates  the  Builder  object  with  the  Director 
object.
iii.   The  client  invokes  the  build  method  on  the  Director 

instance to begin the object creation process. Internally, the 
Director  invokes  different  Builder  methods  required  to 
construct the final object.
iv.  Once the object creation is completed, the client invokes the 
getObject method on the concrete Builder instance to get the 
newly created object.


20

Sequence Diagram


21

Applicability
Builder patterns is useful in a large system.

Builder patterns fits when different variations of 
an  object  may  need  to  be  created  and  the 
inheritance into those objects is well­defined.


22

Example of Builder Class


23

Consider  construction  of  a  home,  Home  is  the 
final  end  product  (object)  that  is  to  be  returned 
as the  output  of  the  construction  process. It will 
have  many  steps,  like  basement  construction, 
wall  construction  and  so  on  roof  construction. 
Finally  the  whole  home  object  is  returned.  Here 
using  the  same  process  you  can  build  houses 
with different properties.


24


25

Java Code in Eclipse