Builder Design Pattern

The builder design pattern is one type of creational design pattern which separates the construction of a complex from its representation so that the same construction process can create various representations. We can easily create a complex object. With the help of a newly created construction code, we can produce various types of representation.

We can solve many object creation related problems using the builder design patterns in object-oriented programming.

Why Use Builder Design Pattern?

The Builder method is used to define a common class that is responsible for building the required object.

Without this technique, we have to create multiple objects to fulfill the main class object. The components of this pattern are given below.

Builder - It is responsible for defining contract to build different parts of one product.
ConcreteBuilder - It is responsible for implementing builder contract.
Product - It is a complex product which consists of various sub part.
ProductServer - It provides the service of the product to who need it.

Problems

Suppose we want to join one of the courses of any famous training center. We go there and ask for the fee structure, placement, timing available, and seat availability. The college administrative will check their system and tell you about what you asked for.

So here is the main purpose of designing the system flexible, well-structured and profitable. The inexperienced developer will create a separate and unique class for every course available in the training center. The developer will then create a separate instance for every class, although that is unnecessary every time. The main problem will arise when a college or training center decides to add a new course; then developers have to add new classes because their code is not much flexible.

Let's understand the above logic through the Python script.

Example -

# concrete course 
class Java(): 

     # Class for Java Langauge
   
def fee_structure(self): 
      self.fee_structure = 10000

   def batch_availibility (self): 
      self.batches = 10

   def __str__(self): 
      return "Java"

# concrete course 
class Swift(): 

   # class for Swift language"""

   def fee_structure(self): 
      self.fee_structure = 5000

   def batch_availibility (self): 
      self.batches = 4

   def __str__(self): 
      return "Swift"


# main method 
if __name__ == "__main__": 

   j = Java() # object for Java
   p = Python() # object for Python
   s = Swift() # object for Swift 

   print(f'Name of Course: {j} and its fee_structure: {j.fee_structure}') 
   print(f'Name of Course: {s} and its fee_structure: {s.fee_structure}') 
   print(f'Name of Course: {p} and its fee_structure: {p.fee_structure}')

Output:

Name of Course: Java and its fee_structure: >
Name of Course: Swift and its fee_structure: >
Name of Course: DSA and its fee_structure: >

Solution

Our primary focus is to get proper information regarding any course from the training institute. It can be Python, Swift, or Java. If we find the particular course, such as finding details about the course, fee structure, timings, batch availability, and batches. It will take a lot of time. Here, we will use the builder patterns to overcome this problem. We can solve the following types of problems using the Builder design pattern.

How a class can create a different representation of a complex object.
How a class can simplify the created complex object.

class Course: 

   def __init__(self): 
      self.fee_structure() 
      self.batch_availibility() 

   def fee_structure(self): 
      raise NotImplementedError 

   def batch_availibility(self): 
      raise NotImplementedError 

   def __repr__(self): 
      return 'fee_structure : {0.fee_structure} | Batches Available : {0.batches}'.format(self) 

# concrete course 
class Python(Course): 

   #Class for Python 

   def fee_structure(self): 
      self.fee_structure = 8000

   def batch_availibility(self): 
      self.batches = 5

   def __str__(self): 
      return "Python"

# concrete course 
class Swift(Course): 

   #Class for swift programming

   def fee_structure(self): 
      self.fee_structure = 10000

   def batch_availibility(self): 
      self.batches = 4

   def __str__(self): 
      return "Swift"

# concrete course 
class Java(Course): 

   # Class for Java programming 

   def fee_structure(self): 
      self.fee_structure = 5000

   def batch_availibility(self): 
      self.batches = 7

   def __str__(self): 
      return "Java"

# Complex Course class
class ComplexCourse: 

   def __repr__(self): 
      return 'fee_structure : {0.fee_structure} | batch_availibility: {0.batches}'.format(self) 

# Complex course class
class Complexcourse(ComplexCourse): 

   def fee_structure(self): 
      self.fee_structure = 7000

   def batch_availibility(self): 
      self.batches = 6

# construct course 
def construct_course(cls): 

   course = cls() 
   course.fee_structure() 
   course.batch_availibility() 

   return course # return the course object 

# main method 
if __name__ == "__main__": 

   P = Python() # object for Python course 
   S = Swift() # object for Swift course 
   J = Java() # object for Java course 

   complex_course = construct_course(Complexcourse) 
   print(complex_course) 

Output:

fee_structure : 18000 | batch_availibility: 5

Benefits of Builder Methods

Below are the advantages of builder methods.

We can change the internal representation of the objects.
It provides the facility to use the same construction code for the other representation.
We can separate the business logic as well as the complex construction code from the each other.
The object can be created step by step, and run recursively.

Demerits of Builder Methods

We define the disadvantages of the builder which are given below.

It increases the code complexity because the builder pattern requires multiple new classes.
Developers make sure that the builder class to be mutable.
It doesn't provide the guarantee to the data members to be initialized.

Applicability of Design Pattern

Builder pattern can be applicable in the following situations.

Builder Method offers us to create a complex object step by step. But it is quite handy if we call the steps recursively. It doesn't allow client code to fetch the incomplete data because it prevents to expose the unfinished object.

Builder Method can be applicable if we create the various representation of the product and that involves the similar step by only differ in the details.

Next TopicPrototype Design Pattern

← prev next →