This lesson builds on Program to an interface. Factory Method is also called a virtual constructor.

Factory Method replaces direct constructor calls with a call to a special method. A base class uses that method to get the objects it needs. Subclasses override the method to change which class gets created. The base class never names a concrete class.

The pattern does not remove new. Objects are still constructed with new. The construction just moves into one method that subclasses can override.

Start from code welded to one class

An analytics app exports reports. The first release supports CSV only, so the export code calls new CsvWriter() and uses it directly. The app succeeds, and customers start asking for JSON and Markdown.

The snippets show the creation boundary. Report, the concrete writers, compress(), and upload() stand in for application code. Assume Report.rows contains string[] rows and upload() returns a File.

class ReportExporter {
  run(report: Report): File {
    const writer = new CsvWriter();          // welded to one format
    for (const row of report.rows) writer.row(row);
    return upload(compress(writer.finish()));
  }
}

Most of the code is about loading, compressing, and uploading. It does not care about the format. But it names CsvWriter, so supporting JSON means a conditional here and in every other place a writer is created. A third format repeats the edit.

Move construction into an overridable method

Factory Method says: call a factory method instead of the constructor, and declare that method's return type as a shared interface. The objects it returns are called products.

interface ReportWriter {
  row(values: string[]): void;
  finish(): string;
}

abstract class ExportJob {
  // The factory method. Subclasses decide which writer to build.
  protected abstract createWriter(): ReportWriter;

  // The real job of the class: a workflow that uses the product.
  run(report: Report): File {
    const writer = this.createWriter();
    for (const row of report.rows) writer.row(row);
    return upload(compress(writer.finish()));
  }
}

class CsvExportJob extends ExportJob {
  protected createWriter() {
    return new CsvWriter();
  }
}

class JsonExportJob extends ExportJob {
  protected createWriter() {
    return new JsonWriter();
  }
}

Subclasses can return different classes only because every product implements ReportWriter, and the factory method promises nothing more specific. The code that calls the factory method, the client code, treats all products the same way.

Map the roles

Role	In this example	Job
Product	ReportWriter	Declares the interface shared by everything the factory method can return
Concrete products	CsvWriter, JsonWriter	Different implementations of the product interface
Creator	ExportJob	Declares the factory method, returning the product interface, and uses its result. The method can be abstract or return a default product.
Concrete creators	CsvExportJob, JsonExportJob	Override the factory method to return a specific product

Reach for it when one of three situations appears

• You do not know ahead of time which classes your code will work with. Factory Method separates the code that constructs products from the code that uses them. Adding a product type means adding a creator subclass.
• You want users of your library or framework to extend its internal components. A web framework's Router builds a RequestLogger internally. Users who want JSON logs need a way in. If the router creates its logger in a createLogger() factory method, a user subclasses the router, overrides that one method, and returns a JsonRequestLogger.
• You want to reuse existing objects instead of rebuilding them. A creation method can return an object from a pool rather than allocate one each time. A plain factory function can also do this. The GoF Factory Method pattern specifically adds an overridable creation step in a creator hierarchy.

Implement it in six steps

1. Make all products follow the same interface, with methods that make sense for every product.
2. Add an empty factory method to the creator class. Its return type is the product interface.
3. Find every product constructor call in the creator. Replace each one with a call to the factory method, moving the construction code into it. A temporary parameter that selects the product type is fine at this stage, even if it means an ugly switch.
4. Create a creator subclass for each product type. Override the factory method and move the matching construction code from the base method into it.
5. If there are too many product types for one subclass each, reuse a control parameter in the subclasses. An export job that uploads to cloud storage might accept a format argument instead of having one subclass per format.
6. If the base factory method is now empty, make it abstract. If something remains, keep it as the default behavior.

Name what it costs

You gain	You pay
No tight coupling between the creator and concrete products	A new subclass for every product type, which can bloat the code
Product construction lives in one place (single responsibility)	The pattern fits best when a creator hierarchy already exists. Building one just for this is heavier.
New product types without changing client code (open/closed)

Do not confuse it with its neighbors

Pattern	Relationship
Abstract Factory	Many designs start with Factory Method and evolve toward Abstract Factory, Prototype, or Builder as they need more flexibility. An abstract factory is usually a set of factory methods.
Prototype	Prototype creates by cloning a configured object, so it needs no creator subclasses and avoids the costs of inheritance. In exchange, the clone often needs complicated initialization after copying. Factory Method relies on inheritance, but its product needs no separate initialization step.
Template Method	Factory Method is a specialization of Template Method: one overridable step whose job is creation. A factory method can also be one step inside a larger template method.
Iterator	Collection subclasses can use a factory method to return the iterator type that matches them.

Retrieve and apply

Continue to Abstract Factory to create whole families of products that must match each other.