Summary
Pattern Name | Abstract Factory Pattern |
Pattern Type | Creational Pattern |
Scope | Object |
Other Names | Kit |
Tagline | Factory of Factory |
Use cases | When we need a factory to generate multiple factory pattern implementations |
Related Patterns | Factory Facade Flyweight Prototype |
Difficulty Level | Medium |
Implementations | ![]() ![]() ![]() ![]() |
Definition
Using the Factory pattern we generate objects based on some criteria. In Abstract factory pattern, we use multiple factory pattern implementations and generate objects based on that.
Abstract factory pattern is also called Factory of Factory, so before reading about Abstract factory pattern, take a look at the Factory pattern.
Implementation
We need to implement multiple factory patterns and then implement a parent factory for those factory implementations.
There are 5 elements in the implementation:
- Abstract Factory Interface: interface that is implemented by concrete abstract factory classes.
- Concrete Abstract Factory Classes: classes that return instances of the concrete class.
- General Interface: interface implemented by concrete classes.
- Concrete Classes: classes implementing factory interface and containing the actual operations. Getting these classes is the final purpose of this implementation.
- Factory Producer: returns instances of concrete factory based on some pre-decided condition. Factory Producer directly uses only Abstract Factory Interface and Concrete Abstract Factory Classes.
Here is a diagram to represent the Abstract Factory Pattern implementation.

Here is how to implement Abstract Factory Pattern:
- First step is to create the classes that we want to use finally. These concrete classes are the main utility classes.
- Create an interface to standardize the utility classes.
- Implemented the interface to the utility classes.
- Create an interface for Abstract Factory and implement how the factory classes will be used to generate objects.
- Create multiple classes (as required) and implement Abstract factory and Use this parent factory to generate objects from the desired classes.
- Create a factory producer class, implement the condition to generate and return the factory class based on some conditions.
Examples
Example #1: Transport
Let’s take the example of a transport system. Take a look at the implementation.
Transport Factory Interface
interface Transport
function start()
function stop()
function repair()
end interface
Transport Classes Implementing Transport Interface
class Bicycle implements Transport
function start()
print "Bicycle Started"
end function
function stop()
print "Bicycle Stopped"
end function
function repair()
print "Bicycle Repair"
end function
end class
class Motorcycle implements Transport
function start()
print "Motorcycle Started"
end function
function stop()
print "Motorcycle Stopped"
end function
function repair()
print "Motorcycle Repair"
end function
end class
class Car implements Transport
function start()
print "Car Started"
end function
function stop()
print "Car Stopped"
end function
function repair()
print "Car Repair"
end function
end class
class Truck implements Transport
function start()
print "Truck Started"
end function
function stop()
print "Truck Stopped"
end function
function repair()
print "Truck Repair"
end function
end class
Abstract Transport Factory Interface
interface AbstractTransportFactory
function getTransport(type: String): Transport
end interface
Two Wheel Transport Factory Class
class TwoWheelTransportFactory implements AbstractTransportFactory
fuction getTransport(String type): Transport
if (type == "bicycle")
return new Bicycle()
end if
if (type == "motorcycle")
return new Motorcycle()
end if
return null
end function
end class
Four Wheel Transport Factory Class
class FourWheelTransportFactory implements AbstractTransportFactory
function getTransport(type: String): Transport
if (type == "car")
return new Car()
end if
if (type == "truck")
return new Truck()
end if
return null
end function
end class
Factory Producer Class
class FactoryProducer
static function getFactory(int numberOfWheels): AbstractTransportFactory
if (numberOfWheels == 2)
return new TwoWheelTransportFactory()
end if
if (numberOfWheels == 4)
return new FourWheelTransportFactory()
end if
return null
end function
end class
Demo
var transportFactory1: AbstractTransportFactory = FactoryProducer.getFactory(2)
Transport transport1 = transportFactory1.getTransport("bicycle")
transport1.start()
var transportFactory2: AbstractTransportFactory = FactoryProducer.getFactory(4)
Transport transport2 = transportFactory2.getTransport("truck")
transport2.start()
Output
Bicycle Started
Truck Started
Code Implementations
Use the following links to check Abstract Factory pattern implementation in specific programming languages.