Design Patterns – Singleton, Observer, Factory, Adapter, Iterator, Strategy, Decorator

More Design Patterns articles:

• Design Patterns Fundamentals (GoF)
• Creational Patterns (Singleton, Factory, Builder, Prototype, Abstract Factory)
• Design Patterns Catalog

This article explains key Design Patterns—including exam questions and reference tags.

In a Nutshell

Design Patterns are proven solutions to recurring problems in software development. They provide standardized templates for common scenarios and improve code quality, maintainability, and team communication.

Technical Overview

The “Gang of Four” (GoF) popularized Design Patterns as tested strategies for typical object-oriented programming challenges. They divide into three categories: Creational Patterns (Singleton, Factory), Structural Patterns (Adapter, Decorator), and Behavioral Patterns (Observer, Strategy, Iterator). Patterns promote loose coupling, high cohesion, and reusability. Rather than ready-made algorithms, they’re abstract solution descriptions that must be adapted to specific contexts.

Key Exam Topics

• Creational Patterns: Singleton, Factory, Abstract Factory, Builder
• Structural Patterns: Adapter, Decorator, Facade, Proxy, Composite
• Behavioral Patterns: Observer, Strategy, Iterator, Command, Template Method
• Singleton: Global instance, thread-safe implementation
• Observer: Publisher-Subscriber, loose coupling between objects
• Factory: Object creation without knowing concrete classes
• Adapter: Interface compatibility between incompatible classes
• Iterator: Sequential access to collection elements without exposing internal structure
• Strategy: Interchangeable algorithms via interface-based implementation

Core Components

1. Singleton Pattern (global instance)
2. Factory Pattern (object creation)
3. Observer Pattern (observer mechanism)
4. Adapter Pattern (interface compatibility)
5. Iterator Pattern (sequential access)
6. Strategy Pattern (algorithm switching)
7. Decorator Pattern (dynamic extension)
8. Template Method Pattern (algorithm skeleton)
9. MVC Pattern (architectural pattern)
10. Registry Pattern (centralized registration)

Practical Example

// Singleton Pattern Example
public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    private DatabaseConnection() {
        // Private Constructor
    }
    
    public static synchronized DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

// Observer Pattern Example
interface Observer {
    void update(String message);
}

class EmailNotification implements Observer {
    public void update(String message) {
        sendEmail(message);
    }
}

Explanation: Singleton ensures a global instance, while Observer enables notification when state changes occur.

Advantages and Disadvantages

Advantages

• Proven solutions for known problems
• Better communication between developers
• Promote loose coupling and high cohesion
• Increase reusability and maintainability

Disadvantages

• Can introduce unnecessary complexity
• Learning curve for beginners
• Sometimes over-engineering simple problems
• Require context-appropriate adaptation

Common Exam Questions (with Quick Answers)

1. Two main categories of Design Patterns? Creational (creation), Structural (structure), Behavioral (behavior).

2. Purpose of the Singleton Pattern? Ensure exactly one instance of a class exists and is globally accessible.

3. When to use the Observer Pattern? When multiple objects need to be notified of state changes in another object.

4. What problem does Factory Pattern solve? Object creation without the client code needing to know concrete classes.

5. Adapter vs. Decorator? Adapter adjusts interfaces; Decorator adds functionality dynamically.

6. Iterator Pattern advantage? Provides uniform access to different collection types without revealing internal structure.

7. When to use Strategy Pattern? When algorithms need to be interchangeable without changing client code.

8. MVC Pattern components? Model (data), View (presentation), Controller (logic connecting Model and View).

Key Resources

1. https://refactoring.guru/design-patterns
2. https://de.wikipedia.org/wiki/Entwurfsmuster
3. https://www.oracle.com/technical-resources/articles/j2ee/patterns

---

Recommended Reading: Design Patterns