🧠 What is Factory Design Pattern?

The Factory Pattern is a creational pattern that provides an interface for creating objects but allows subclasses to decide which class to instantiate.

🔧 When to Use It ?

Use Factory Pattern when:

• When you don’t know ahead of time what class you need
• When you want to delegate object creation to subclasses
• When you want to work with objects through a common interface

🧩 Scenario

You’re building a system which interacts with speak behavior of different Animals. To start with we have three Animals : Dot, Cat and Duck. All animals implement a speak method. We will implement a client program which uses these Animal object to invoke their speak method.

animal.py

# Direct class implementations
class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

class Duck:
    def speak(self):
        return "Quack!"

client.py

def create_animal(animal_type: str):
    if animal_type.lower() == "dog":
        return Dog()
    elif animal_type.lower() == "cat":
        return Cat()
    elif animal_type.lower() == "duck":
        return Duck()
    else:
        raise ValueError("Invalid animal type")

# Usage
def main():
    # Client needs to know about all concrete classes
    dog = Dog()
    cat = Cat()
    duck = Duck()
    
    # Or using the function
    dog2 = create_animal("dog")
    
    print(dog.speak())
    print(cat.speak())
    print(duck.speak())

❌ Problem in this approach

In the above example you have:

1. Tight Coupling:

Client code is directly dependent on concrete classes :

• Any changes to class structure affect client code
• No common interface enforced

2. Code Maintenance:

When your system grows:

• Adding new animal types requires modifying client code
• No standardization of methods across classes
• Object creation logic is scattered

3. No Abstraction:

Without providing any abstraction to different Animal classes :

• There is no guarantee that all animals will implement required methods
• Missing interface enforcement
• Harder to ensure consistency

4. Code Duplication:

• Creation logic might be duplicated across different parts of the application
• No centralized point for object creation

Imaging there are different clients using our Animal objects. Each one of them would have to implement their own logic of create_animal and need to know all type of Animal objects that are supported.

Factory Pattern Fix: Centralizing object creation logic

key Components

Abstract Product (Animal):

• Defines the interface for products
• Uses ABC (Abstract Base Class) in Python

Concrete Products (Dog, Cat, Duck):

• Implement the abstract product interface
• Represent the actual objects being created

Factory (AnimalFactory):

• Contains the logic for object creation
• Returns appropriate concrete product based on input

classDiagram
    class Product {
        <<abstract>>
        +operation()* abstract
    }
    
    class ConcreteProductA {
        +operation()
    }
    
    class ConcreteProductB {
        +operation()
    }
    
    class ConcreteProductC {
        +operation()
    }
    
    class Factory {
        +createProduct(type: string) Product
    }
    
    Product <|-- ConcreteProductA
    Product <|-- ConcreteProductB
    Product <|-- ConcreteProductC
    Factory ..> Product : creates
    Factory ..> ConcreteProductA : creates
    Factory ..> ConcreteProductB : creates
    Factory ..> ConcreteProductC : creates

animal.py

from abc import ABC, abstractmethod

# Step 1: Create Abstract Product
class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

# Step 2: Create Concrete Products
class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Duck(Animal):
    def speak(self):
        return "Quack!"

# Step 3: Create Factory
class AnimalFactory:
    @staticmethod
    def create_animal(animal_type: str) -> Animal:
        if animal_type.lower() == "dog":
            return Dog()
        elif animal_type.lower() == "cat":
            return Cat()
        elif animal_type.lower() == "duck":
            return Duck()
        else:
            raise ValueError("Invalid animal type")

client.py

def main():
    factory = AnimalFactory()
    
    # Create different animals
    dog = factory.create_animal("dog")
    cat = factory.create_animal("cat")
    duck = factory.create_animal("duck")
    
    # Make them speak
    print(dog.speak())  # Output: Woof!
    print(cat.speak())  # Output: Meow!
    print(duck.speak())  # Output: Quack!

if __name__ == "__main__":
    main()

Benefits of Using Factory Pattern Here

• Encapsulation: Object creation logic is centralized
• Flexibility: Easy to add new product types
• Loose coupling: Client code is separated from object creation