Design Patterns Every Developer Should Know: From Singleton to Factory

In the world of software development, design patterns are proven solutions to common problems that arise during the design phase of software architecture. They provide a blueprint for writing efficient, maintainable, and scalable code. Understanding and implementing these patterns can drastically improve the quality of your applications.

In this article, we will explore several key design patterns that every developer should be familiar with, from the Singleton to the Factory pattern. Whether you're working with Python, Java, or any other language, these patterns are valuable tools for improving your development process.

1. Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This pattern is commonly used for managing global resources, such as a database connection or a logging service, where you want to ensure that only one instance of a class exists throughout the lifetime of the application.

When to use it:

• When you need to control access to a shared resource.
• When the system should have only one instance of a class (e.g., database connection).

Example (Python):

class Singleton:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# Usage
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # True        

2. Factory Pattern

The Factory pattern is used to create objects without specifying the exact class of object that will be created. It provides an interface for creating objects in a super class but allows subclasses to alter the type of objects that will be created.

When to use it:

• When the creation process of an object is complex or involves multiple steps.
• When the exact class of the object may not be known until runtime.

Example (Python):

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

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

class AnimalFactory:
    def create_animal(self, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()

# Usage
factory = AnimalFactory()
animal = factory.create_animal("dog")
print(animal.speak())  # Woof!        

3. Observer Pattern

The Observer pattern allows an object (subject) to notify a list of dependent objects (observers) automatically when its state changes. This is useful in scenarios like event handling systems or UI updates where multiple components need to react to changes in the application state.

When to use it:

• When an object needs to notify multiple objects about a change in state without knowing who or what those objects are.

Example (Python):

class Subject:
    def __init__(self):
        self._observers = []

    def add_observer(self, observer):
        self._observers.append(observer)

    def notify_observers(self):
        for observer in self._observers:
            observer.update()

class Observer:
    def update(self):
        pass

class ConcreteObserver(Observer):
    def update(self):
        print("State changed!")

# Usage
subject = Subject()
observer1 = ConcreteObserver()
subject.add_observer(observer1)
subject.notify_observers()  # State changed!        

4. Strategy Pattern

The Strategy pattern defines a family of algorithms and allows the algorithm to be selected at runtime. This is particularly useful when there are several ways to perform a task, and you want to decouple the code that chooses the algorithm from the algorithm implementation itself.

When to use it:

• When you have multiple ways to perform a task and want to choose the algorithm dynamically.
• When you want to avoid using a large number of conditionals in your code.

Example (Python):

class Strategy:
    def execute(self):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self):
        return "Strategy A"

class ConcreteStrategyB(Strategy):
    def execute(self):
        return "Strategy B"

class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy

    def execute_strategy(self):
        return self._strategy.execute()

# Usage
context = Context(ConcreteStrategyA())
print(context.execute_strategy())  # Strategy A
context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy())  # Strategy B        

5. Decorator Pattern

The Decorator pattern allows you to dynamically add behavior to an object at runtime, without affecting the behavior of other objects of the same class. It is often used for adding functionalities like logging, access control, or caching to existing objects.

When to use it:

• When you need to add responsibilities to objects in a flexible and reusable way.
• When subclassing would result in an explosion of classes.

Example (Python):

class Coffee:
    def cost(self):
        return 5

class MilkDecorator:
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 2

class SugarDecorator:
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 1

# Usage
coffee = Coffee()
print(coffee.cost())  # 5
milk_coffee = MilkDecorator(coffee)
print(milk_coffee.cost())  # 7
sugared_milk_coffee = SugarDecorator(milk_coffee)
print(sugared_milk_coffee.cost())  # 8        

Conclusion

These five design patterns—Singleton, Factory, Observer, Strategy, and Decorator—are foundational in software development. They enable developers to write cleaner, more maintainable code that is easier to understand and extend. By leveraging these patterns in your projects, you can address common design challenges with elegant, reusable solutions.

Need expert help with web or mobile development? Contact us at [email protected] or fill out this form.