Abstract Factory

tl;dr - A factory of factories; a factory that groups the individual but related/dependent factories together without specifying their concrete classes.

An abstract factory is a design pattern used in object-oriented programming that provides an interface for creating families of related or dependent objects without specifying their concrete classes. It falls under the category of creational design patterns.

Here’s a breakdown of the key components and concepts involved in the abstract factory pattern:

1. Abstract Factory Interface:

   • Defines the interface for creating a family of related or dependent objects.

   • Declares a set of abstract methods, each responsible for creating a different type of object.

2. Concrete Factories:

   • Implement the abstract factory interface to produce a family of related objects.

   • Each concrete factory corresponds to a specific variant or family of objects.

3. Abstract Products:

   • Define the interface for a group of related or dependent products.

   • The abstract product classes declare the methods that concrete product classes must implement.

4. Concrete Products:

   • Implement the abstract product interface.

   • Each concrete product corresponds to a specific variant or family of products.

5. Client:

   • Utilizes the abstract factory and abstract product interfaces to create families of related objects.

   • Remains unaware of the specific classes of objects it creates.

The main idea is to encapsulate the creation of objects in a separate hierarchy (the abstract factory) and allow the client code to work with this hierarchy without specifying concrete classes. This provides flexibility, as you can easily switch between different families of objects by using a different concrete factory.

The abstract factory pattern is similar to the factory method pattern. The key difference is that the factory method pattern is a single method, whereas the abstract factory pattern is an object. The factory method is just a method, whereas the abstract factory is an object that has multiple factory methods on it.

--- UML diagram ---

 +------------------+           +------------------+
 | AbstractProductA |           | AbstractProductB |
 +------------------+           +------------------+
        |                               |
        |                               |
        +--------------+----------------+
                       |
               +------------------+
               |    Client        |
               +------------------+
                       |
                +-----------------+
                | AbstractFactory |
                +-----------------+
                       |
               +------------------+
               | ConcreteFactory1 |
               +------------------+
                   |           |
      +-------------------+ +-------------------+
      | ConcreteProductA1 | | ConcreteProductB1 |
      +-------------------+ +-------------------+

--- Python Example ---

 from __future__ import annotations
 from abc import ABC, abstractmethod


 class AbstractFactory(ABC):
     """
     The Abstract Factory interface defines a set of methods to create various
     abstract products. These products form a family that shares a common theme
     or concept. Typically, products within a family can collaborate with each
     other, and different families of products are incompatible.
     """
     @abstractmethod
     def create_product_a(self) -> AbstractProductA:
         pass

     @abstractmethod
     def create_product_b(self) -> AbstractProductB:
         pass


 class ConcreteFactory1(AbstractFactory):
     """
     Concrete Factories produce a family of products belonging to a specific
     variant. The factory ensures that the resulting products are compatible.
     Notably, the method signatures of Concrete Factory return abstract products,
     while actual concrete products are instantiated inside the methods.
     """

     def create_product_a(self) -> AbstractProductA:
         return ConcreteProductA1()

     def create_product_b(self) -> AbstractProductB:
         return ConcreteProductB1()


 class ConcreteFactory2(AbstractFactory):
     """
     Each Concrete Factory corresponds to a specific product variant.
     """

     def create_product_a(self) -> AbstractProductA:
         return ConcreteProductA2()

     def create_product_b(self) -> AbstractProductB:
         return ConcreteProductB2()


 class AbstractProductA(ABC):
     """
     Each unique product in a product family should have a base interface. All
     product variants must adhere to this interface.
     """

     @abstractmethod
     def perform_function_a(self) -> str:
         pass


 # Concrete Products from Concrete Factories...


 class ConcreteProductA1(AbstractProductA):
     def perform_function_a(self) -> str:
         return "The outcome of product A1."


 class ConcreteProductA2(AbstractProductA):
     def perform_function_a(self) -> str:
         return "The outcome of product A2."


 class AbstractProductB(ABC):
     """
     This is the base interface for another product. All products can interact
     with each other, but meaningful interaction occurs only between products of
     the same concrete variant.
     """
     @abstractmethod
     def execute_function_b(self) -> None:
         """
         Product B can perform its own functionality...
         """
         pass

     @abstractmethod
     def collaborate_function_b(self, collaborator: AbstractProductA) -> None:
         """
         ...and it can collaborate with Product A.

         The Abstract Factory ensures that all products it creates belong to the
         same variant, ensuring compatibility.
         """
         pass


 # Concrete Products are created by corresponding Concrete Factories.


 class ConcreteProductB1(AbstractProductB):
     def execute_function_b(self) -> str:
         return "The outcome of product B1."

     """
     Product B1 is only compatible with Product A1. Nevertheless, it accepts any
     instance of AbstractProductA as an argument.
     """

     def collaborate_function_b(self, collaborator: AbstractProductA) -> str:
         result = collaborator.perform_function_a()
         return f"The outcome of B1 collaborating with ({result})"


 class ConcreteProductB2(AbstractProductB):
     def execute_function_b(self) -> str:
         return "The outcome of product B2."

     def collaborate_function_b(self, collaborator: AbstractProductA):
         """
         Product B2 is only compatible with Product A2. Nevertheless, it accepts
         any instance of AbstractProductA as an argument.
         """
         result = collaborator.perform_function_a()
         return f"The outcome of B2 collaborating with ({result})"


 def utilize_factory(factory: AbstractFactory) -> None:
     """
     The client code interacts with factories and products solely through
     abstract types: AbstractFactory and AbstractProduct. This enables the
     passing of any factory or product subclass to the client code without
     causing disruptions.
     """
     product_a = factory.create_product_a()
     product_b = factory.create_product_b()

     print(f"{product_b.execute_function_b()}")
     print(f"{product_b.collaborate_function_b(product_a)}", end="")


 if __name__ == "__main__":
     """
     The client code can function with any concrete factory class.
     """
     print("Client: Testing client code with the first factory type:")
     utilize_factory(ConcreteFactory1())

     print("\n")

     print("Client: Testing the same client code with the second factory type:")
     utilize_factory(ConcreteFactory2())

--- Java Example ---

 interface AbstractFactory {
     AbstractProductA createProductA();

     AbstractProductB createProductB();
 }

 interface AbstractProductA {
     String performFunctionA();
 }

 interface AbstractProductB {
     String executeFunctionB();

     String collaborateFunctionB(AbstractProductA collaborator);
 }

 class ConcreteFactory1 implements AbstractFactory {
     public AbstractProductA createProductA() {
         return new ConcreteProductA1();
     }

     public AbstractProductB createProductB() {
         return new ConcreteProductB1();
     }
 }

 class ConcreteFactory2 implements AbstractFactory {
     public AbstractProductA createProductA() {
         return new ConcreteProductA2();
     }

     public AbstractProductB createProductB() {
         return new ConcreteProductB2();
     }
 }

 class ConcreteProductA1 implements AbstractProductA {
     public String performFunctionA() {
         return "The outcome of product A1.";
     }
 }

 class ConcreteProductA2 implements AbstractProductA {
     public String performFunctionA() {
         return "The outcome of product A2.";
     }
 }

 class ConcreteProductB1 implements AbstractProductB {
     public String executeFunctionB() {
         return "The outcome of product B1.";
     }

     public String collaborateFunctionB(AbstractProductA collaborator) {
         String result = collaborator.performFunctionA();
         return "The outcome of B1 collaborating with (" + result + ")";
     }
 }

 class ConcreteProductB2 implements AbstractProductB {
     public String executeFunctionB() {
         return "The outcome of product B2.";
     }

     public String collaborateFunctionB(AbstractProductA collaborator) {
         String result = collaborator.performFunctionA();
         return "The outcome of B2 collaborating with (" + result + ")";
     }
 }

 public class Client {
     public static void utilizeFactory(AbstractFactory factory) {
         AbstractProductA productA = factory.createProductA();
         AbstractProductB productB = factory.createProductB();

         System.out.println(productB.executeFunctionB());
         System.out.println(productB.collaborateFunctionB(productA));
     }

     public static void main(String[] args) {
         System.out.println("Client: Testing client code with the first factory type:");
         utilizeFactory(new ConcreteFactory1());

         System.out.println("\n");

         System.out.println("Client: Testing the same client code with the second factory type:");
         utilizeFactory(new ConcreteFactory2());
     }
 }