Scribd
Upload
12 views

cs711_33

The document discusses the Builder Design Pattern, which separates the construction of complex objects from their representation, allowing for different representations to be created using the same construction process. It highlights the limitations of traditional object construction methods in complex scenarios and introduces a Director object to manage the construction process, improving modularity and reducing code changes. The Builder pattern is particularly useful in large systems where variations of an object need to be created efficiently.

Uploaded by

Faizan Berlas
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
12 views

cs711_33

The document discusses the Builder Design Pattern, which separates the construction of complex objects from their representation, allowing for different representations to be created using the same construction process. It highlights the limitations of traditional object construction methods in complex scenarios and introduces a Director object to manage the construction process, improving modularity and reducing code changes. The Builder pattern is particularly useful in large systems where variations of an object need to be created efficiently.

Uploaded by

Faizan Berlas
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 28

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 can create
different representations.
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


26
27

Comparison of Creational

Patterns
28

You might also like