Factory Method

Design Patterns

Mar 16, 2024

When designing software systems, there are scenarios where the exact type of objects to be created may vary or need to be determined at runtime. Direct instantiation of objects using specific class constructors can lead to tightly coupled code, making it difficult to extend or modify the system.

The pattern

The Factory Method is a creational design pattern addresses this issue by defining an interface for creating objects, while allowing subclasses to provide the concrete implementation of the object creation process. This way, the responsibility of object instantiation is delegated to subclasses, promoting loose coupling and enhancing flexibility.

To implement the Factory Method pattern, define a common interface or base class for the objects to be created, ensuring that all subclasses implement the necessary methods. Create concrete subclasses that provide specific implementations of the object creation method defined in the interface. Use a factory class or method to encapsulate the logic for creating objects.

This factory class or method should allow clients to create objects without specifying their concrete types, thereby promoting flexibility and maintainability. Clients should interact with the factory class or method to obtain instances of objects, without needing to know the specific implementation classes.

Pros

Promotes Loose Coupling: By delegating the responsibility of object creation to subclasses or factory methods, the pattern reduces the direct dependencies between the client code and the concrete implementation classes. This promotes loose coupling, making it easier to maintain and extend the system.
Enhances Flexibility: The Factory Method pattern allows for the creation of objects of different types or variations without modifying the client code. This makes the system more flexible and adaptable to changes in requirements or new use cases.
Encourages Abstraction: By defining interfaces or abstract classes for object creation and leaving the actual implementation to subclasses, the pattern encourages abstraction and separation of concerns. This leads to cleaner, more modular code that is easier to understand and maintain.
Facilitates Testing: The use of interfaces and abstraction makes it easier to mock or substitute different implementations during testing, leading to more robust and reliable tests.

Cons

Complexity: Implementing the Factory Method pattern may introduce additional complexity to the codebase, especially if there are many variations of objects to be created or if the hierarchy of subclasses is deep. This complexity can make the code harder to understand and maintain, particularly for developers unfamiliar with the pattern.
Increased Number of Classes: Introducing subclasses or factory methods for object creation may result in a larger number of classes in the system. This can lead to a more extensive class hierarchy, which may be difficult to manage and navigate.
Potential Overhead: In some cases, the use of the Factory Method pattern may introduce overhead due to the additional abstraction layers and indirection involved in object creation. This overhead can impact performance, especially in systems with high object creation rates or tight resource constraints.
Runtime Complexity: Since the determination of the concrete type of objects is deferred to runtime, it may introduce complexity in understanding the behavior of the system at compile-time. This can make it harder to reason about the code and debug issues related to object creation and initialization.

Implementation

In this section, we delve into the implementation details of the Factory Method design pattern across different programming languages, including C++, Python, and Java. By examining code snippets in each language, we explore how the pattern is applied to create objects, promote loose coupling, and enhance flexibility in software design.

JAVA

interface Product {
    void execute();
}

class FirstProduct implements Product {
    @Override
    public void execute() {
        System.out.println("FirstProduct");
    }
}

class SecondProduct implements Product {
    @Override
    public void execute() {
        System.out.println("SecondProduct");
    }
}

interface Creator {
    Product createProduct();
}

class FirstCreator implements Creator {
    @Override
    public Product createProduct() {
        return new FirstProduct();
    }
}

class SecondCreator implements Creator {
    @Override
    public Product createProduct() {
        return new SecondProduct();
    }
}

In this code snippet, the Factory Method pattern is implemented through the use of interfaces and concrete implementations in Java. The Product interface defines a common interface for all products, specifying the execute method. Two concrete product classes, FirstProduct and SecondProduct, implement this interface, providing specific implementations for the execute method. The Creator interface serves as the factory interface, defining a method createProduct for creating products. Two concrete creator classes, FirstCreator and SecondCreator, implement this interface and provide concrete implementations for creating instances of FirstProduct and SecondProduct, respectively.

Creator factory = new FirstCreator();
Product product = factory.createProduct();
product.execute();

factory = new SecondCreator();
product = factory.createProduct();
product.execute();

Initially, a Creator instance named factory is instantiated with new FirstCreator(), representing the creation of a concrete factory for producing products. Subsequently, factory.createProduct() is called, invoking the factory method to create a product instance. This approach allows the specific implementation details of product creation to be encapsulated within the concrete factory (FirstCreator). Similarly, a new factory instance is created with new SecondCreator(), indicating the instantiation of another concrete factory for a different type of product. Again, factory.createProduct() is invoked to produce a product instance, showcasing the flexibility and polymorphic behavior offered by the Factory Method pattern. Through this structure, clients can seamlessly create various types of products without directly referencing their concrete implementations, fostering loose coupling and maintainable code.

C++

class Product {
public:
    virtual void execute() = 0;
    virtual ~Product() = default;
};

class FirstProduct : public Product {
public:
    void execute() override {
        std::cout << "FirstProduct" << std::endl;
    }
};

class SecondProduct : public Product {
public:
    void execute() override {
        std::cout << "SecondProduct" << std::endl;
    }
};

class Creator {
public:
    virtual Product* createProduct() = 0;
    virtual ~Creator() = default;
};

class FirstCreator : public Creator {
public:
    Product* createProduct() override {
        return new FirstProduct();
    }
};

class SecondCreator : public Creator {
public:
    Product* createProduct() override {
        return new SecondProduct();
    }
};

In this code snippet, the Factory Method pattern is exemplified in C++. Firstly, an abstract base class Product is defined, encapsulating the common interface execute() for all products. Two concrete product classes, FirstProduct and SecondProduct, inherit from Product and provide specific implementations for the execute() method. Additionally, a Creator abstract base class is declared with a pure virtual method createProduct(), responsible for creating instances of Product. Two concrete creator classes, FirstCreator and SecondCreator, inherit from Creator and implement the createProduct() method to instantiate FirstProduct and SecondProduct objects, respectively. Through this structure, clients can utilize the Creator interface to generate instances of various products, without being concerned with the specific details of their creation.

Creator* factory = new FirstCreator();
Product* product = factory->createProduct();
product->execute();
delete product;
delete factory;

Initially, a pointer factory of type Creator is instantiated with new FirstCreator(), indicating the creation of a concrete factory for generating products. Subsequently, factory->createProduct() is invoked, utilizing the factory method to produce a product instance. This design allows the specific implementation details of product creation to be encapsulated within the concrete factory (FirstCreator). The execute() method is then called on the product object, demonstrating the use of the product interface. Finally, both the product and factory instances are properly deallocated using delete to avoid memory leaks. This implementation adheres to the principles of loose coupling and abstraction promoted by the Factory Method pattern, enabling clients to create diverse products without directly referencing their concrete implementations.

Python

class Product:
    def execute(self):
        pass

class FirstProduct(Product):
    def execute(self):
        print("FirstProduct")

class SecondProduct(Product):
    def execute(self):
        print("SecondProduct")

class Creator:
    def create_product(self):
        pass

class FirstCreator(Creator):
    def create_product(self):
        return FirstProduct()

class SecondCreator(Creator):
    def create_product(self):
        return SecondProduct()

In this code snippet, the Factory Method pattern is demonstrated in Python. Initially, base class Product defines a common interface method execute() for all products. Two concrete product classes, FirstProduct and SecondProduct, inherit from Product and provide specific implementations for the execute() method. Similarly, abstract base class Creator declares a method create_product(), responsible for creating instances of Product. Concrete creator classes, FirstCreator and SecondCreator, inherit from Creator and implement the create_product() method to instantiate FirstProduct and SecondProduct objects, respectively. Through this structure, clients can use the Creator interface to generate instances of different products without needing to know the specific details of their creation.

factory = FirstCreator()
product = factory.create_product()
product.execute()

factory = SecondCreator()
product = factory.create_product()
product.execute()

factory is assigned an instance of FirstCreator, indicating the creation of a concrete factory for generating products of a specific type. Subsequently, factory.create_product() is called, utilizing the factory method to produce a product instance. This approach allows the specific implementation details of product creation to be encapsulated within the concrete factory (FirstCreator). Similarly, a new instance of SecondCreator is assigned to factory, indicating the instantiation of another concrete factory for a different type of product. Again, factory.create_product() is invoked to produce a product instance, showcasing the flexibility and polymorphic behavior offered by the Factory Method pattern. Through this structure, clients can seamlessly create various types of products without directly referencing their concrete implementations, fostering loose coupling and maintainable code.

Summary

The Factory Method design pattern facilitates object creation by defining an interface or base class for creating objects and allowing subclasses to provide the concrete implementations. This pattern promotes loose coupling, enhances flexibility, and encourages abstraction, making it easier to extend and maintain software systems. By delegating the responsibility of object creation to subclasses or factory methods, the Factory Method pattern enables the creation of objects in a flexible and maintainable manner, suitable for various programming languages and scenarios.

slys.dev

Discussion about this post