The factory method is a creational design pattern. It’s intent is to create instances of classes without having to explicitly call
new on them.
Why would you want to do this?
The problem this pattern tries to solve is to have a mechanism for creating an instance of a class without knowing what type will be created.
The GOF defines the gactory method as:
“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”
To be the factory method, it has to handle the actual creation of the new instance, if it doesn’t create it, it may be the template pattern or something else.
This example will try to be very descriptive:
class Transport def get_to_location # the get_new_vehicle method # is our factory method, which will # determine which vehicle to create vehicle = get_new_vehicle vehicle.drive # each vehicle class implements the drive method end def get_new_vehicle raise "abstract method, implement in children class" end
A derivative class of the
Transport class will implement the factory method
class WilburTransport < Transport # Wilbur wishes he drives a Ferrari :-) def get_new_vehicle Ferrari.new end end class publicTransport < Transport def get_new_vehicle Bus.new end end
Some notes about the Factory Pattern
- You should use the factory pattern when you have a class that does not know what objects it should create, or when you want the subclasses to determine the type of objects that should be created.
- It helps with the single responsibility principle by moving the creation of objects to one part of the system making it easier to maintain.
- Helps you conform with the open/close principle in that you can add new types of objects without breaking existing functionality.