Introduction to the Abstract Factory Pattern

Welcome back! You’ve already explored the power of the Factory Method Pattern and how it promotes flexibility in your code design. Today, we are moving a step further by diving into the Abstract Factory Pattern. This pattern will help you create families of related objects without specifying their concrete classes.

Understanding the Abstract Factory Pattern

The Abstract Factory Pattern is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern is particularly useful when you need to ensure that a set of related objects are created together, maintaining consistency across your application. To understand this better, let's consider a scenario where you are developing a graphical user interface (GUI) toolkit. Your toolkit should support multiple operating systems, such as Windows and Mac. Each OS has its own set of UI components, like buttons and checkboxes. Using the Abstract Factory Pattern, you can define interfaces for these components and create their concrete implementations for each OS.

Defining Abstract Product Interfaces

Let's learn how to use the Abstract Factory Pattern. First, we will define abstract product interfaces for the UI components. These interfaces will ensure that each concrete product implements the necessary behavior. Below is the basic definition of abstract products for buttons and checkboxes: Python from abc import ABC, abstractmethod # Abstract Product A class Button(ABC): @abstractmethod def paint(self): pass Here, Button is an abstract base class defining the paint method to be implemented by all concrete buttons. This ensures that any button created by our factories adheres to a common interface. Python # Abstract Product B class Checkbox(ABC): @abstractmethod def paint(self): pass Similarly, the Checkbox class sets the contract for all checkbox components, making sure they implement the paint method. By defining these abstract products, we ensure a consistent interface across different operating systems.

Creating Concrete Product Implementations

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Code Overview

Here is the complete code:

Python

from abc import ABC, abstractmethod

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

# Abstract Product A1
class WinButton(Button):
    def paint(self):
        print("Rendering a button in a Windows style.")

# Abstract Product A2
class MacButton(Button):
    def paint(self):
        print("Rendering a button in a Mac style.")

# Abstract Product B
class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

# Concrete Product B1
class WinCheckbox(Checkbox):
    def paint(self):
        print("Rendering a checkbox in a Windows style.")

# Concrete Product B2
class MacCheckbox(Checkbox):
    def paint(self):
        print("Rendering a checkbox in a Mac style.")

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

    @abstractmethod
    def create_checkbox(self):
        pass

# Concrete Factory 1
class WinFactory(GUIFactory):
    def create_button(self):
        return WinButton()

    def create_checkbox(self):
        return WinCheckbox()

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

    def create_checkbox(self):
        return MacCheckbox()

# Client code
class Application:
    def __init__(self, factory):
        self.factory = factory
        self.button = self.factory.create_button()
        self.checkbox = self.factory.create_checkbox()

    def paint(self):
        self.button.paint()
        self.checkbox.paint()

if __name__ == '__main__':
    os_type = "Windows"  # Change to "Mac" to see Mac UI
    factory = None

    if os_type == "Windows":
        factory = WinFactory()
    elif os_type == "Mac":
        factory = MacFactory()

    if factory:
        app = Application(factory)
        app.paint()
        # Output:
        # Rendering a button in a Windows style.
        # Rendering a checkbox in a Windows style.
    else:
        print("Unknown OS type.")

from abc import ABC, abstractmethod

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

# Abstract Product A1
class WinButton(Button):
    def paint(self):
        print("Rendering a button in a Windows style.")

# Abstract Product A2
class MacButton(Button):
    def paint(self):
        print("Rendering a button in a Mac style.")

# Abstract Product B
class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

# Concrete Product B1
class WinCheckbox(Checkbox):
    def paint(self):
        print("Rendering a checkbox in a Windows style.")

# Concrete Product B2
class MacCheckbox(Checkbox):
    def paint(self):
        print("Rendering a checkbox in a Mac style.")

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

    @abstractmethod
    def create_checkbox(self):
        pass

# Concrete Factory 1
class WinFactory(GUIFactory):
    def create_button(self):
        return WinButton()

    def create_checkbox(self):
        return WinCheckbox()

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

    def create_checkbox(self):
        return MacCheckbox()

# Client code
class Application:
    def __init__(self, factory):
        self.factory = factory
        self.button = self.factory.create_button()
        self.checkbox = self.factory.create_checkbox()

    def paint(self):
        self.button.paint()
        self.checkbox.paint()

if __name__ == '__main__':
    os_type = "Windows"  # Change to "Mac" to see Mac UI
    factory = None

    if os_type == "Windows":
        factory = WinFactory()
    elif os_type == "Mac":
        factory = MacFactory()

    if factory:
        app = Application(factory)
        app.paint()
        # Output:
        # Rendering a button in a Windows style.
        # Rendering a checkbox in a Windows style.
    else:
        print("Unknown OS type.")

This completed example demonstrates the Abstract Factory Pattern in action, providing a robust method for creating families of related objects.

Introduction to the Abstract Factory Pattern

Understanding the Abstract Factory Pattern

Defining Abstract Product Interfaces

Creating Concrete Product Implementations

Join the 1M+ learners on CodeSignal

Defining the Abstract Factory Interface

Creating Concrete Factory Implementations

Implementing the Client Code

Code Overview

Abstract Factory vs Factory Method: A Comparison

Conclusion