How It Works

• The client requests a product from the Abstract Factory without knowing where or how the objects are created.
• The Concrete Factory is responsible for creating the products. This factory is designed so that it only creates products that belong to a specific variant.
• The products that are created by the factory are referred to as a family and are related/dependent on each other.

Implementation of Abstract Factory Pattern

Imagine you're the owner of a charming café, determined to offer delightful experiences to your customers with their favorite drinks and pastries.

You face an interesting challenge: creating two distinct types of cafes, a CoffeeCafe and a TeaCafe, each with its own unique menu. This is where the Abstract Factory Pattern comes into play, providing you with a recipe to design diverse product families that cater to coffee and tea enthusiasts' preferences.

Now, let's introduce the magic of the Abstract Factory Pattern to our cafes:

• Create an abstract CafeFactory interface with methods like createDrink() and createPastry().
• Implement two concrete factories: CoffeeCafeFactory and TeaCafeFactory, each providing their own versions of createDrink() and createPastry().
• The result? You can effortlessly switch between cafes and their menus using the corresponding factory. Your code remains elegant, modular, and easily extensible. Using the code would be more understandable, so let's discuss it through pseudocode and implementation in different languages.

Pseudocode

# Define Abstract Product Interfaces
class Drink:
    def serve()

class Pastry:
    def serve()

# Define Concrete Products
class CoffeeDrink(Drink):
    def serve():
        return "Serving Coffee"

class CoffeePastry(Pastry):
    def serve():
        return "Serving Croissant"

class TeaDrink(Drink):
    def serve():
        return "Serving Tea"

class TeaPastry(Pastry):
    def serve():
        return "Serving Scone"

# Define Abstract Factory Interface
class CafeFactory:
    def createDrink()
    def createPastry()

# Define Concrete Factories
class CoffeeCafeFactory(CafeFactory):
    def createDrink():
        return CoffeeDrink()

    def createPastry():
        return CoffeePastry()

class TeaCafeFactory(CafeFactory):
    def createDrink():
        return TeaDrink()

    def createPastry():
        return TeaPastry()

# Main Function
function main():
    # Creating a Coffee Cafe
    coffee_factory = CoffeeCafeFactory()
    coffee = coffee_factory.createDrink()
    croissant = coffee_factory.createPastry()

    print(coffee.serve())  # Output: Serving Coffee
    print(croissant.serve())  # Output: Serving Croissant

    # Creating a Tea Cafe
    tea_factory = TeaCafeFactory()
    tea = tea_factory.createDrink()
    scone = tea_factory.createPastry()

    print(tea.serve())  # Output: Serving Tea
    print(scone.serve())  # Output: Serving Scone

# Call the Main Function
main()

The pseudocode outlines the structure of the code and defines classes and methods.

• Abstract Product Interfaces:
  • Drink and Pastry are abstract classes defining the interfaces for drinks and pastries.
• Concrete Products:
  • CoffeeDrink, CoffeePastry, TeaDrink, and TeaPastry are concrete classes implementing the interfaces defined by Drink and Pastry.
• Abstract Factory Interface:
  • CafeFactory is an abstract class defining methods to create drinks and pastries.
• Concrete Factories:
  • CoffeeCafeFactory and TeaCafeFactory are concrete classes implementing the CafeFactory interface. They create instances of specific drinks and pastries.
• Main Function:
  • main() is the entry point of the program. It demonstrates the creation of different types of cafes, creating drinks and pastries, and printing their respective serve messages.