Top 5 Design Patterns Every Software Developer Should Know

Design patterns are reusable solutions to common programming problems. They provide a structured and proven approach to designing robust and flexible software. Whether you are a beginner or an experienced software developer, understanding and applying design patterns can significantly improve the quality of your code.

In this article, we will explore the top 5 design patterns that every software developer should know: Singleton, Factory, Observer, Adapter, and Strategy.

Singleton

The Singleton pattern ensures that only one instance of a class is created and provides a global point of access to it. This pattern is useful when you need to restrict the instantiation of a class to a single object, such as a database connection or a configuration manager.

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Factory

The Factory pattern is used to create objects without exposing the instantiation logic to the client. It provides an interface for creating objects of a superclass, but allows subclasses to decide which class to instantiate.

class Animal:
    def speak(self):
        pass

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

class Cat(Animal):
    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()
        else:
            return None

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

Observer

The Observer pattern defines a one-to-many dependency between objects, where a subject notifies its observers of any state changes. This pattern promotes loose coupling between objects, making it easier to maintain and extend the codebase.

#include <iostream>
#include <vector>

class Observer {
public:
    virtual void update() = 0;
};

class Subject {
    std::vector<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void detach(Observer* observer) {
        // Remove the observer from the list
    }

    void notify() {
        for (auto observer : observers) {
            observer->update();
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        std::cout << "Subject state has changed." << std::endl;
    }
};

int main() {
    Subject subject;
    ConcreteObserver observer;

    subject.attach(&observer);
    subject.notify();  // Output: "Subject state has changed."

    return 0;
}

Adapter

The Adapter pattern allows incompatible interfaces to work together. It converts the interface of one class into another interface that clients expect. This pattern is useful when you need to integrate existing functionality without modifying the existing code.

class OldPrinter {
    print(text) {
        console.log("Printing: " + text);
    }
}

class NewPrinter {
    write(text) {
        console.log("Writing: " + text);
    }
}

class PrinterAdapter {
    constructor(printer) {
        this.printer = printer;
    }

    print(text) {
        if (this.printer instanceof OldPrinter) {
            this.printer.print(text);
        } else if (this.printer instanceof NewPrinter) {
            this.printer.write(text);
        }
    }
}

// Usage
const oldPrinter = new OldPrinter();
const newPrinter = new NewPrinter();

const adapter = new PrinterAdapter(newPrinter);
adapter.print("Hello, world!");  // Output: "Writing: Hello, world!"

Strategy

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable within a context. It allows you to vary the behavior of an object during runtime by selecting an appropriate strategy from a set of available algorithms.

class Strategy
  def execute
    raise NotImplementedError, "Subclasses must implement the execute method"
  end
end

class ConcreteStrategyA < Strategy
  def execute
    puts "Executing strategy A"
  end
end

class ConcreteStrategyB < Strategy
  def execute
    puts "Executing strategy B"
  end
end

class Context
  attr_writer :strategy

  def execute_strategy
    @strategy.execute
  end
end

# Usage
context = Context.new

context.strategy = ConcreteStrategyA.new
context.execute_strategy  # Output: "Executing strategy A"

context.strategy = ConcreteStrategyB.new
context.execute_strategy  # Output: "Executing strategy B"

These five design patterns are just a few examples of the many design patterns available in software development. Understanding and applying design patterns can greatly enhance your programming skills and improve the maintainability and flexibility of your code. Take the time to explore and experiment with different design patterns to become a more proficient software developer.