Understanding Common Design Patterns in Software Development

Table of Contents

1. Creational Patterns
• Singleton Pattern
• Factory Method Pattern

2. Structural Patterns
• Adapter Pattern
• Decorator Pattern

3. Behavioral Patterns
• Observer Pattern
• Strategy Pattern

4. Conclusion

Creational Patterns

Singleton Pattern

When to Use

• When exactly one object is needed to coordinate actions across the system.

• Managing shared resources like configuration settings or connection pools.

Code Example (Python)

class SingletonMeta(type):
    _instance = None

    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__call__(*args, **kwargs)
        return cls._instance

class ConfigurationManager(metaclass=SingletonMeta):
    def __init__(self):
        self.settings = {}

# Usage
config1 = ConfigurationManager()
config2 = ConfigurationManager()
print(config1 is config2)  # Output: True

Factory Method Pattern

When to Use

• When a class cannot anticipate the type of objects it needs to create beforehand.

• To delegate the responsibility of object instantiation to subclasses.

Code Example (Java)

abstract class Transport {
    public abstract void deliver();
}

class Truck extends Transport {
    public void deliver() {
        System.out.println("Deliver by land in a box.");
    }
}

class Ship extends Transport {
    public void deliver() {
        System.out.println("Deliver by sea in a container.");
    }
}

abstract class Logistics {  // factory
    public void planDelivery() {
        Transport transport = createTransport();
        transport.deliver();
    }
    public abstract Transport createTransport();  // factory method
}

class RoadLogistics extends Logistics {
    public Transport createTransport() {
        return new Truck();
    }
}

class SeaLogistics extends Logistics {
    public Transport createTransport() {
        return new Ship();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Logistics logistics = new RoadLogistics();
        logistics.planDelivery();  // Output: Deliver by land in a box.
    }
}

Structural Patterns

Adapter Pattern

When to Use

• To integrate classes that couldn't otherwise work together due to incompatible interfaces.

• To reuse existing classes without modifying their source code.

Code Example (C#)

// Existing interface
public interface ITarget {
    void Request();
}

// Adaptee with an incompatible interface
public class Adaptee {
    public void SpecificRequest() {
        Console.WriteLine("Called SpecificRequest()");
    }
}

// Adapter making Adaptee compatible with ITarget
public class Adapter : ITarget {
    private readonly Adaptee _adaptee;
    public Adapter(Adaptee adaptee) {
        _adaptee = adaptee;
    }
    public void Request() {
        _adaptee.SpecificRequest();
    }
}

// Usage
class Program {
    static void Main() {
        Adaptee adaptee = new Adaptee();
        ITarget target = new Adapter(adaptee);
        target.Request();  // Output: Called SpecificRequest()
    }
}

Decorator Pattern

When to Use

• To add responsibilities to individual objects dynamically without affecting other objects.

• When subclassing would result in an explosion of subclasses to cover every combination.

Code Example (JavaScript)

// Component
class Coffee {
    getCost() {
        return 5;
    }
    getDescription() {
        return "Coffee";
    }
}

// Decorator
class MilkDecorator {
    constructor(coffee) {
        this.coffee = coffee;
    }
    getCost() {
        return this.coffee.getCost() + 1;
    }
    getDescription() {
        return this.coffee.getDescription() + ", Milk";
    }
}

// Usage
let myCoffee = new Coffee();
myCoffee = new MilkDecorator(myCoffee);

console.log(myCoffee.getCost());        // Output: 6
console.log(myCoffee.getDescription()); // Output: Coffee, Milk

Behavioral Patterns

Observer Pattern

When to Use

• When changes to one object require changing others, and the number of objects is unknown.

• To decouple the subject and observers, allowing them to vary independently.

Code Example (Python)

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

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

    @property
    def state(self):
        return self._state

    @state.setter
    def state(self, value):
        self._state = value
        self.notify()

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

class ConcreteObserver:
    def update(self, subject):
        print(f"Observer: Reacted to state change to {subject.state}")

# Usage
subject = Subject()
observer_a = ConcreteObserver()
observer_b = ConcreteObserver()

subject.attach(observer_a)
subject.attach(observer_b)

subject.state = "New State"
# Output:
# Observer: Reacted to state change to New State
# Observer: Reacted to state change to New State

Strategy Pattern

When to Use

• When multiple algorithms are needed, and you want to switch between them at runtime.

• To avoid conditional statements for selecting desired behavior.

Code Example (Java)

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid $" + amount + " using Credit Card.");
    }
}

class PayPalStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid $" + amount + " using PayPal.");
    }
}

class ShoppingCart {
    private PaymentStrategy paymentStrategy;
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.setPaymentStrategy(new CreditCardStrategy());
        cart.checkout(100);  // Output: Paid $100 using Credit Card.

        cart.setPaymentStrategy(new PayPalStrategy());
        cart.checkout(200);  // Output: Paid $200 using PayPal.
    }
}

Conclusion

• Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides.

• Official documentation and tutorials on design patterns in various programming languages.