Difference Between Builder Design Pattern and Factory Design Pattern

Design patterns provide proven solutions to common problems in software design. The Builder and Factory patterns are two popular creational design patterns. The Builder pattern constructs complex objects step by step. In contrast, the Factory pattern creates objects without specifying their exact class. Both patterns streamline object creation but differ in their methods. In this article, we will learn these differences, offering examples and use cases for each.

What is a Builder Design Pattern?

The Builder Design Pattern is a creational pattern used to construct complex objects step by step. It separates the construction of an object from its representation, enabling the same construction process to create different representations. This pattern is particularly useful when an object requires multiple components or configurations. By using the Builder Pattern, you can ensure that the creation process is more controlled and flexible, making it easier to manage the complexity of the object being built.

• Step-by-Step Construction: The Builder Pattern breaks down the construction of an object into discrete steps.
• Separation of Construction and Representation: It allows the construction process to be independent of the object's final representation.
• Flexibility: The same construction process can produce different representations of the object.
• Reusability: Builders can be reused for creating different types of objects.
• Controlled Construction Process: Each step in the construction process can be customized, ensuring precise control over the final product.
• Improved Readability: The code becomes more readable and maintainable by clearly defining the construction process.

What is a Factory Design Pattern?

The Factory Design Pattern is a creational pattern that defines an interface for creating objects but lets subclasses decide which class to instantiate. This pattern promotes loose coupling by delegating the responsibility of object creation to subclasses, making the system more flexible and extensible. The Factory Pattern is particularly useful when the type of objects to be created is uncertain or when you need to centralize object creation to ensure consistency.

• Interface for Object Creation: The Factory Pattern defines a common interface for creating objects.
• Delegation to Subclasses: Subclasses determine the class of the object to be created, enhancing flexibility.
• Loose Coupling: It reduces dependency between classes, promoting more modular and maintainable code.
• Centralized Object Creation: Ensures that object creation is centralized, maintaining consistency across the system.
• Simplifies Code Maintenance: By encapsulating object creation, the pattern simplifies code maintenance and updates.
• Supports Open/Closed Principle: New types of objects can be added without modifying existing code, adhering to the open/closed principle.

Builder Design Pattern vs. Factory Design Pattern

Here are the differences between the Builder Design Pattern and the Factory Design Pattern:

Example Implementations of Factory and Builder Design Pattern

To better understand the Builder and Factory Design Patterns, let's look at some practical examples. These examples will illustrate how each pattern is applied in real-world scenarios.

1. Builder Design Pattern Example

The Builder Design Pattern is useful when constructing complex objects with multiple configurations. Consider building a house where you need to specify different parts like the foundation, structure, roof, and furnishings. The Builder Pattern allows you to construct this complex object step by step.

public class House {
    private String foundation;
    private String structure;
    private String roof;
    private boolean furnished;


    private House(HouseBuilder builder) {
        this.foundation = builder.foundation;
        this.structure = builder.structure;
        this.roof = builder.roof;
        this.furnished = builder.furnished;
    }


    public static class HouseBuilder {
        private String foundation;
        private String structure;
        private String roof;
        private boolean furnished;


        public HouseBuilder setFoundation(String foundation) {
            this.foundation = foundation;
            return this;
        }


        public HouseBuilder setStructure(String structure) {
            this.structure = structure;
            return this;
        }


        public HouseBuilder setRoof(String roof) {
            this.roof = roof;
            return this;
        }


        public HouseBuilder setFurnished(boolean furnished) {
            this.furnished = furnished;
            return this;
        }


        public House build() {
            return new House(this);
        }
    }
}

2. Factory Design Pattern Example

The Factory Design Pattern simplifies object creation by defining an interface for creating an object. Consider a shape factory that can create different shapes like circles and squares based on input.

interface Shape {
    void draw();
}


class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }
}


class Square implements Shape {
    public void draw() {
        System.out.println("Drawing Square");
    }
}


class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

Use Cases of Builder Design Pattern and Factory Design Pattern

Here are the specific use cases for the Builder Design Pattern and the Factory Design Pattern:

1. Builder Design Pattern Use Cases

• Complex Object Construction: The Builder Pattern is ideal when constructing complex objects with many parts. For example, building a house involves setting up the foundation, structure, roof, and interiors. This pattern allows for step-by-step construction and customization.
• Objects with Numerous Configurations: When an object can have multiple configurations, the Builder Pattern simplifies the creation process. For instance, creating a customizable meal in a restaurant ordering system where customers can choose different ingredients and sizes.
• Readable and Maintainable Code: The Builder Pattern makes code more readable and maintainable by separating the construction logic. It is especially useful in scenarios like creating a detailed report with multiple sections, headers, footers, and data tables.

2. Factory Design Pattern Use Cases

• Uncertain Object Types at Runtime: The Factory Pattern is beneficial when the exact type of object to create is unknown until runtime. For example, creating different types of shapes (circle, square) in a graphics application based on user input.
• Centralized Object Creation: When you need to centralize object creation to maintain consistency, the Factory Pattern is effective. For instance, creating database connections where the type of database (SQL, NoSQL) may vary, but the connection creation process needs to be consistent.
• Promoting Loose Coupling: The Factory Pattern helps in promoting loose coupling by delegating the creation responsibility to subclasses. This is useful in systems where you want to reduce dependencies, such as creating different types of documents (PDF, Word) without the main class knowing the details of each type.

Conclusion

The Builder and Factory Design Patterns each serve unique purposes in object creation. The Builder Pattern excels in constructing complex objects with detailed configurations. The Factory Pattern simplifies the creation process by abstracting object instantiation. Understanding their differences helps in choosing the right pattern for your needs. Both patterns enhance code flexibility and maintainability, making them essential tools for developers.