What is the factory Design Pattern?

What is the Factory Design Pattern?

The Factory Design Pattern is a creational pattern that provides a way to create objects without specifying the exact class of object that will be created. It allows for the creation of objects without exposing the internal details of the object creation process, making it a flexible and reusable design pattern.

Problem it Solves

The Factory Design Pattern solves the problem of creating objects without specifying the exact class of object that will be created. In other words, it provides a way to create objects without knowing the type of object that will be created. This is particularly useful in situations where:

• The type of object to be created is unknown or dynamic.
• The object creation process is complex or requires multiple steps.
• The object creation process is tightly coupled with the business logic.

Key Components

The Factory Design Pattern consists of the following key components:

• Product: The product is the object that is being created.
• ProductFactory: The product factory is responsible for creating the product.
• ConcreteProduct: The concrete product is the actual object that is being created.
• AbstractProductFactory: The abstract product factory is the base class for all product factories.

How it Works

Here’s a step-by-step explanation of how the Factory Design Pattern works:

1. Create an instance of the product factory: The product factory is created, and an instance of it is created.
2. Create an instance of the concrete product: An instance of the concrete product is created using the product factory.
3. Use the concrete product: The concrete product is used to perform the desired action.

Benefits

The Factory Design Pattern provides several benefits, including:

• Decoupling: The object creation process is decoupled from the business logic, making it easier to modify or replace the object creation process without affecting the business logic.
• Reusability: The Factory Design Pattern promotes reusability by providing a way to create objects without exposing the internal details of the object creation process.
• Flexibility: The Factory Design Pattern provides flexibility by allowing for the creation of objects without specifying the exact class of object that will be created.

Example Use Case

Here’s an example use case for the Factory Design Pattern:

Suppose we are building a system that manages different types of vehicles, such as cars, trucks, and buses. We want to create a system that can create vehicles without specifying the exact type of vehicle.

# Product

class Vehicle:

    def __init__(self, brand, model):

        self.brand = brand

        self.model = model



# ConcreteProduct

class Car(Vehicle):

    def __init__(self, brand, model, num_doors):

        super().__init__(brand, model)

        self.num_doors = num_doors



# AbstractProductFactory

class VehicleFactory:

    def create_vehicle(self, brand, model, num_doors):

        return Car(brand, model, num_doors)



# ConcreteProductFactory

class CarFactory(VehicleFactory):

    def create_vehicle(self, brand, model, num_doors):

        return Car(brand, model, num_doors)



# Client code

factory = CarFactory()

car = factory.create_vehicle("Toyota", "Camry", 4)

print(car.brand)  # Output: Toyota

print(car.model)  # Output: Camry

print(car.num_doors)  # Output: 4

In this example, the VehicleFactory class is responsible for creating vehicles, and the CarFactory class is a concrete product factory that creates Car objects. The Car class is a concrete product that is created using the CarFactory class.

Advantages of the Factory Design Pattern

The Factory Design Pattern has several advantages, including:

• Improved flexibility: The Factory Design Pattern provides flexibility by allowing for the creation of objects without specifying the exact class of object that will be created.
• Reduced coupling: The Factory Design Pattern reduces coupling between the object creation process and the business logic, making it easier to modify or replace the object creation process without affecting the business logic.
• Easier maintenance: The Factory Design Pattern makes it easier to maintain the object creation process by providing a way to create objects without exposing the internal details of the object creation process.

Conclusion

The Factory Design Pattern is a creational pattern that provides a way to create objects without specifying the exact class of object that will be created. It allows for the creation of objects without exposing the internal details of the object creation process, making it a flexible and reusable design pattern. The Factory Design Pattern provides several benefits, including improved flexibility, reduced coupling, and easier maintenance.