Factory Pattern

Introduction

The Factory Pattern is a creational design pattern that provides an interface for creating objects without specifying their exact class. Instead of using constructors directly, the pattern delegates the instantiation to a factory method, promoting loose coupling and improved scalability in software architecture.

This pattern is widely used in object-oriented programming (OOP) to handle object creation logic, especially when:

• The exact type of object is determined at runtime
• The creation logic is complex or repetitive
• You want to centralize object creation

The Factory Pattern belongs to the Gang of Four (GoF) design patterns and comes in several variants, including Simple Factory, Factory Method, and Abstract Factory.

Real-World Analogy

Think of a car manufacturing plant:

• The factory receives orders for different car models (e.g., Sedan, SUV).
• It uses a standard process to build them.
• The client doesn’t need to know how each model is built—only that it receives a working car.

In code, the factory hides the instantiation details and returns the desired object.

Key Goals of the Factory Pattern

Simple Factory Pattern (Informal)

Although not part of the official GoF catalog, a Simple Factory is a commonly used variant that encapsulates object creation in a static method.

Example in Python

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

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

class AnimalFactory:
    @staticmethod
    def get_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Unknown animal type")

animal = AnimalFactory.get_animal("dog")
print(animal.speak())  # Output: Woof!

The client doesn’t know whether it received a Dog or Cat object—just that it got an animal that can speak().

Factory Method Pattern (GoF Standard)

The Factory Method is a design pattern that defines an interface for creating an object, but lets subclasses decide which class to instantiate.

Key Participants

UML Sketch

           Creator
             |
      +------|------+
      |             |
ConcreteCreator1  ConcreteCreator2
      |             |
    Product       Product

Factory Method Example – Java

// Product
interface Notification {
    void notifyUser();
}

// Concrete Products
class EmailNotification implements Notification {
    public void notifyUser() {
        System.out.println("Sending an Email Notification");
    }
}

class SMSNotification implements Notification {
    public void notifyUser() {
        System.out.println("Sending an SMS Notification");
    }
}

// Creator
abstract class NotificationFactory {
    public abstract Notification createNotification();
}

// Concrete Creator
class EmailFactory extends NotificationFactory {
    public Notification createNotification() {
        return new EmailNotification();
    }
}

class SMSFactory extends NotificationFactory {
    public Notification createNotification() {
        return new SMSNotification();
    }
}

Usage:

NotificationFactory factory = new EmailFactory();
Notification notification = factory.createNotification();
notification.notifyUser();

Abstract Factory Pattern

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Example use case: building cross-platform GUI apps (Windows vs macOS UI components).

Benefits of Factory Pattern

Drawbacks

Factory Pattern in Other Languages

C++

class Animal {
public:
    virtual void speak() = 0;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};

class AnimalFactory {
public:
    static Animal* createAnimal(const std::string& type) {
        if (type == "dog") return new Dog();
        if (type == "cat") return new Cat();
        return nullptr;
    }
};

JavaScript

class Dog {
    speak() { return "Woof!" }
}

class Cat {
    speak() { return "Meow!" }
}

function animalFactory(type) {
    if (type === "dog") return new Dog();
    if (type === "cat") return new Cat();
    throw "Unknown type";
}

const a = animalFactory("dog");
console.log(a.speak()); // Woof!

When to Use Factory Pattern

Use the Factory Pattern when:

• The class to instantiate isn’t known until runtime
• You want to encapsulate complex creation logic
• You need polymorphism without coupling to specific classes
• Objects share a common interface
• You anticipate the need to introduce new types without modifying existing code

Alternatives and Comparisons

Summary

Related Keywords

• Abstract Factory
• Constructor Injection
• Dependency Injection
• Design Patterns
• Factory Method
• Inversion of Control
• Interface Segregation
• Object-Oriented Programming
• Product Interface
• Simple Factory