Demystifying Design Patterns: Abstract Factory Design Pattern

clean-architecture-clean-desk
Share
  1. Demystifying Design Patterns: Singleton Design Pattern
  2. Demystifying Design Patterns: Factory Method Design Pattern
  3. Demystifying Design Patterns: Abstract Factory Design Pattern
  4. Demystifying Design Patterns: Builder Design Pattern
  5. Demystifying Design Patterns: Prototype Design Pattern
  6. Demystifying Design Patterns: Adapter Design Pattern
  7. Demystifying Design Patterns: Bridge Design Pattern
  8. Demystifying Design Patterns: Composite Design Pattern
  9. Demystifying Design Patterns: Decorator Design Pattern
  10. Demystifying Design Patterns: Proxy Design Pattern
  11. Demystifying Design Patterns: Observer Design Pattern
  12. Demystifying Design Patterns: Strategy Design Pattern
  13. Demystifying Design Patterns: Command Design Pattern
  14. Demystifying Design Patterns: State Design Pattern
  15. Demystifying Design Patterns: Chain of Responsibility Design Pattern
  16. Demystifying Design Patterns: Visitor Design Pattern
  17. Demystifying Design Patterns: Template Method Design Pattern

Welcome to the third installment of our “Demystifying Design Patterns” series. In this article, we’ll dive deep into the Abstract Factory Design Pattern—an advanced creational pattern that provides an elegant solution for creating families of related objects. We will explore the pattern’s intricacies, compare it to the Factory Method pattern, examine real-world applications, and discuss its role in designing extensible systems. 

Introduction

The Abstract Factory Design Pattern belongs to the creational design pattern category and addresses the complex task of creating families of related or dependent objects without specifying their concrete classes. It promotes encapsulation, ensuring that the created objects are compatible with each other and belong to a consistent family of products.

Exploring the Abstract Factory Pattern

To understand the Abstract Factory pattern, let’s break it down into its core components:

– Abstract Factory: An interface or abstract class that declares creation methods for multiple types of objects, forming a family of related products.

– Concrete Factory: Subclasses of the Abstract Factory that implement the creation methods, producing specific product objects.

– Abstract Product: An interface or abstract class that defines a common interface for product objects within a family.

– Concrete Product: Subclasses of the Abstract Product that implement the product-specific functionality.

The Abstract Factory pattern excels when a system must be configured with multiple families of objects, and it ensures that objects within a family work seamlessly together.

Abstract Factory vs. Factory Method

It’s essential to differentiate between the Abstract Factory and Factory Method patterns:

– Abstract Factory: Focuses on creating families of related objects. Clients work with abstract factories to create entire families of objects, ensuring their compatibility.

– Factory Method: Concentrates on creating individual objects within a family. Clients work with concrete factories (or creators) to create specific objects.

Implementing Abstract Factory in Complex Systems

Let’s illustrate the power of the Abstract Factory pattern with a complex system example—a graphical user interface framework. Such a framework must create various UI components that not only share a consistent style but also interact seamlessly with each other.

example-1-abstract-factory-design-pattern

Java Example:

// Abstract Product: Button
interface Button {
    void render();
}

// Concrete Product: WindowsButton
class WindowsButton implements Button {
    public void render() {
        System.out.println("Rendering a Windows button");
    }
}

// Concrete Product: MacButton
class MacButton implements Button {
    public void render() {
        System.out.println("Rendering a Mac button");
    }
}

// Abstract Product: TextField
interface TextField {
    void render();
}

// Concrete Product: WindowsTextField
class WindowsTextField implements TextField {
    public void render() {
        System.out.println("Rendering a Windows text field");
    }
}

// Concrete Product: MacTextField
class MacTextField implements TextField {
    public void render() {
        System.out.println("Rendering a Mac text field");
    }
}

// Abstract Factory: GUIFactory
interface GUIFactory {
    Button createButton();
    TextField createTextField();
}

// Concrete Factory: WindowsFactory
class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }

    public TextField createTextField() {
        return new WindowsTextField();
    }
}

// Concrete Factory: MacFactory
class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }

    public TextField createTextField() {
        return new MacTextField();
    }
}

Python Example:

from abc import ABC, abstractmethod

# Abstract Product: Button
class Button(ABC):
    @abstractmethod
    def render(self):
        pass

# Concrete Product: WindowsButton
class WindowsButton(Button):
    def render(self):
        print("Rendering a Windows button")

# Concrete Product: MacButton
class MacButton(Button):
    def render(self):
        print("Rendering a Mac button")

# Abstract Product: TextField
class TextField(ABC):
    @abstractmethod
    def render(self):
        pass

# Concrete Product: WindowsTextField
class WindowsTextField(TextField):
    def render(self):
        print("Rendering a Windows text field")

# Concrete Product: MacTextField
class MacTextField(TextField):
    def render(self):
        print("Rendering a Mac text field")

# Abstract Factory: GUIFactory
class GUIFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_text_field(self):
        pass

# Concrete Factory: WindowsFactory
class WindowsFactory(GUIFactory):
    def create_button(self):
        return WindowsButton()

    def create_text_field(self):
        return WindowsTextField()

# Concrete Factory: MacFactory
class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()

    def create_text_field(self):
        return MacTextField()

# Client code
def create_ui(factory):
    button = factory.create_button()
    text_field = factory.create_text_field()
    return button, text_field

# Usage
windows_ui = create_ui(WindowsFactory())
mac_ui = create_ui(MacFactory())

for ui_element in windows_ui + mac_ui:
    ui_element.render()

C# Example:

using System;

// Abstract Product: Button
public interface IButton
{
    void Render();
}

// Concrete Product: WindowsButton
public class WindowsButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Rendering a Windows button");
    }
}

// Concrete Product: MacButton
public class MacButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Rendering a Mac button");
    }
}

// Abstract Product: TextField
public interface ITextField
{
    void Render();
}

// Concrete Product: WindowsTextField
public class WindowsTextField : ITextField
{
    public void Render()
    {
        Console.WriteLine("Rendering a Windows text field");
    }
}

// Concrete Product: MacTextField
public class MacTextField : ITextField
{
    public void Render()
    {
        Console.WriteLine("Rendering a Mac text field");
    }
}

// Abstract Factory: GUIFactory
public interface IGUIFactory
{
    IButton CreateButton();
    ITextField CreateTextField();
}

// Concrete Factory: WindowsFactory
public class WindowsFactory : IGUIFactory
{
    public IButton CreateButton()
    {
        return new WindowsButton();
    }

    public ITextField CreateTextField()
    {
        return new WindowsTextField();
    }
}

// Concrete Factory: MacFactory
public class MacFactory : IGUIFactory
{
    public IButton CreateButton()
    {
        return new MacButton();
    }

    public ITextField CreateTextField()
    {
        return new MacTextField();
    }
}

// Client code
public class Client
{
    public void CreateUI(IGUIFactory factory)
    {
        var button = factory.CreateButton();
        var textField = factory.CreateTextField();
        button.Render();
        textField.Render();
    }
}

// Usage
var client = new Client();
client.CreateUI(new WindowsFactory());
client.CreateUI(new MacFactory());

Designing for Extensibility with Abstract Factory

One of the significant advantages of the Abstract Factory pattern is its extensibility. New product families and variants can be seamlessly integrated into the system without requiring modifications to existing code. This extensibility is a key factor in designing scalable and maintainable systems.

Conclusion

The Abstract Factory Design Pattern is a potent solution for managing families of related objects in complex systems. It promotes encapsulation, ensures compatibility between objects within a family, and allows for seamless extensibility. Real-world applications of this pattern can be found in graphical user interfaces, database drivers, and various other software systems.

In our next article, we will continue our journey through design patterns. Stay tuned for more insights and demystification!



  • September 19, 2023