The Factory Method Pattern

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.”

Example

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 get_new_vehicle:

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

  1. 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.
  2. It helps with the single responsibility principle by moving the creation of objects to one part of the system making it easier to maintain.
  3. Helps you conform with the open/close principle in that you can add new types of objects without breaking existing functionality.

Leave a Reply

Your email address will not be published. Required fields are marked *