Abstract Factory Design Pattern Example

overview

What is Abstract Factory pattern and what is it for? According to Design Patterns by GoF, the intent of Abstract Factory is to,

Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 

source: GoF

Abstract Factory conforms to the principle of "program to an interface, not an implementation." In Abstract Factory pattern, the class that is responsible for creating concrete objects (Products) is said to be a Factory class. In order to create different types of concrete Products, different type of concrete Factory classes will be used. Each Factory is just a collection of factory methods (e.g. CreateProductA(), CreateProductB()). Each factory method creates a concrete Product of the same family. 

The client code's factory method creates the final product based on a given factory. This extra layer of abstraction is provided to the client code by introducing the concept of factory. This is the most common way to implement the Abstract Factory pattern.

example

AbstractFactory / AbstractProduct / Client

[1] A factory method that creates an empty maze to begin with, not a final end product.
[2] Because each Factory knows how to make the product of their own family. The client code (MazeGame) simply has a factory method which depends on an abstract factory to create the final end Product - a final version of Maze. As demonstrated above, the Factory class adds an layer of abstraction to the client without exposing the implementation details of the products.

Another good example of an Abstract Factory in use could be UI toolkits across Windows, Mac and Linux, UI composites such as windows, buttons as described on DZone.

scenarios

Use Abstract Factory patter when you want to:

• create multiple families of products,
• provide a library of products without exposing the implementation details of the products.

comparison

Abstract Factory vs Builder: 

They are quite similar with the following differences: 

• Abstract Factory emphasizes a family of product objects (either simple or complex). Builder focuses on constructing a complex product object step by step. 
• Abstract Factory focuses on what is made. Builder focuses on how product is made. 
• In Abstract Factory, every method call creates and returns different objects. In Builder pattern, only the last method call (build() or getResult()) returns the object, while other calls partially build/config the end product. 

Abstract Factory vs. Factory Method

• Differ in their intent. In Abstract Factory pattern, a client class delegates the responsibility of object instantiation to another object (an Factory object) via composition whereas the Factory Method pattern uses inheritance and relies on a subclass to handle the desired object instantiation.
• An Abstract Factory class builds on top of Factory Method pattern as seen in its derived Factory classes. An Abstract Factory is used to be passed to (or referenced by) other client code to create the final product using a specific Concrete Factory.