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 is a concept overview of essential Design Patterns, including exam questions and key topics.

In a Nutshell

Design Patterns are proven solutions to recurring problems in software development. They provide standardized blueprints for common scenarios, improving code quality, maintainability, and communication across teams.

Core Definition

Design Patterns were popularized by the “Gang of Four” (GoF) and describe tested solution strategies for typical challenges in object-oriented programming. They fall into three categories: Creational Patterns (instantiation mechanisms like Singleton and Factory), Structural Patterns (object composition like Adapter and Decorator), and Behavioral Patterns (communication and responsibility distribution like Observer, Strategy, and Iterator). Patterns promote loose coupling, high cohesion, and code reuse. Rather than complete algorithms, they are abstract solution templates that must be adapted to fit your specific context.

Exam Essentials

• 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 with thread-safe implementation
• Observer: Publisher-Subscriber model with loose coupling between objects
• Factory: Object creation without requiring knowledge of concrete classes
• Adapter: Interface compatibility between incompatible classes
• Iterator: Sequential access to collection elements without exposing internal structure
• Strategy: Interchangeable algorithms through interface-based implementation

Core Components

1. Singleton Pattern (global instance)
2. Factory Pattern (object creation)
3. Observer Pattern (publish-subscribe mechanism)
4. Adapter Pattern (interface compatibility)
5. Iterator Pattern (sequential access)
6. Strategy Pattern (algorithm switching)
7. Decorator Pattern (dynamic behavior addition)
8. Template Method Pattern (algorithm skeleton)
9. MVC Pattern (architectural structure)
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 single global instance, while Observer enables notification when object state changes.

Strengths and Weaknesses

Strengths

• Proven solutions for known problems
• Improved team communication through shared vocabulary
• Encourage loose coupling and high cohesion
• Increase code reuse and maintainability

Weaknesses

• Can introduce unnecessary complexity
• Steeper learning curve for beginners
• Sometimes over-engineered for simple problems
• Require context-aware customization

Common Exam Questions (with Brief Answers)

1. Three main categories of Design Patterns? Creational (object creation), Structural (object composition), Behavioral (object interaction and responsibility).

2. Purpose of the Singleton Pattern? Ensures only one instance of a class exists and provides global access to it.

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

4. What problem does the Factory Pattern solve? Decouples object creation from client code, eliminating the need to know concrete class names.

5. Difference between Adapter and Decorator? Adapter converts incompatible interfaces; Decorator dynamically adds functionality.

6. Advantage of the Iterator Pattern? Provides uniform access to different collection types without exposing their internal structure.

7. When should you use the Strategy Pattern? When algorithms must be interchangeable without changing client code.

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

Key Resources

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

---

Recommended Reading: Design Patterns