Factory Method: Let Each Carrier Decide

Pass 1's simple factory picked a class from a name; when shipping runs the same steps for every carrier and needs both a label and a pickup that must match, two simple factories with the same if chain drift apart, so each carrier's subclass decides what to create, with methods the shared steps call: the Factory Method pattern.

Journeyman · OOP · Updated

By

After this lesson you can

  • Let each subclass decide which object to create, so the shared steps never name a concrete class
  • Spot the smells that point to Factory Method: simple factories with the same if chain on one name that must stay in step

Key takeaways

  • The smell: more than one simple factory with an if chain on the same name, which all have to stay in step.
  • The cause: "which carrier?" is decided again in every factory, so the things that belong together (a carrier's label and its pickup) are made in different places.
  • The fix: the shared steps call a method to make what they need, and each carrier's subclass overrides it to make its own: a factory method.
  • Pass 1's simple factory doesn't go away: it picks the carrier once, by name, and from then on the carrier makes its own things.
  • Handing in the "make one" functions does the same job without subclasses.

Before this: Simple Factory: One Place That Says new (Pass 1), and Template Method: Same Routine, Your Own Step, the lesson before this one.

In Pass 1, a simple factory gave "which class goes with this name?" one home, and pies showed up everywhere at once. Shipping a package at Lakeside Parcel runs the same steps for every carrier: make the carrier's label, then book the carrier's pickup. QuickShip sends a van; EcoFreight sends a cargo bike; SameDay sends a courier. That's two things to make per carrier, and they have to match. The tracker gave each one a simple factory, which looked like the Pass 1 lesson applied twice. This lesson shows why twice isn't the same as once, and ends with Pass 1's factory grown up: Factory Method.

The symptom: two factories, one name, out of step

Ship runs the steps. MakeLabel and MakePickup are the two simple factories. SameDay signed on last month:

Package parcel = new Package(42);
foreach (string carrier in new List<string> { "QuickShip", "EcoFreight", "SameDay" })
{
    Console.WriteLine(Ship(parcel, carrier));
}

// The same steps for every carrier: make its label, book its pickup.
string Ship(Package parcel, string carrier)
{
    ILabel label = MakeLabel(carrier, parcel);
    IPickup pickup = MakePickup(carrier);
    return quot;{carrier}: label {label.Text}, pickup by {pickup.Text}";
}

ILabel MakeLabel(string carrier, Package parcel)
{
    if (carrier == "QuickShip") { return new QuickShipLabel(parcel); }
    if (carrier == "EcoFreight") { return new EcoFreightLabel(parcel); }
    if (carrier == "SameDay") { return new SameDayLabel(parcel); }
    throw new ArgumentException("No such carrier: " + carrier);
}

IPickup MakePickup(string carrier)
{
    if (carrier == "EcoFreight") { return new CargoBikePickup(); }
    return new VanPickup();
}

record Package(int Id);

interface ILabel { string Text { get; } }
record QuickShipLabel(Package Parcel) : ILabel { public string Text => quot;QS-{Parcel.Id:D4}"; }
record EcoFreightLabel(Package Parcel) : ILabel { public string Text => quot;ECO{Parcel.Id}"; }
record SameDayLabel(Package Parcel) : ILabel { public string Text => quot;SD/{Parcel.Id}"; }

interface IPickup { string Text { get; } }
class VanPickup : IPickup { public string Text => "van"; }
class CargoBikePickup : IPickup { public string Text => "cargo bike"; }
class CourierPickup : IPickup { public string Text => "courier"; }
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
record Package(int id) {}

interface Label { String text(); }
record QuickShipLabel(Package parcel) implements Label { public String text() { return String.format("QS-%04d", parcel.id()); } }
record EcoFreightLabel(Package parcel) implements Label { public String text() { return "ECO" + parcel.id(); } }
record SameDayLabel(Package parcel) implements Label { public String text() { return "SD/" + parcel.id(); } }

interface Pickup { String text(); }
class VanPickup implements Pickup { public String text() { return "van"; } }
class CargoBikePickup implements Pickup { public String text() { return "cargo bike"; } }
class CourierPickup implements Pickup { public String text() { return "courier"; } }

Label makeLabel(String carrier, Package parcel) {
    if (carrier.equals("QuickShip")) { return new QuickShipLabel(parcel); }
    if (carrier.equals("EcoFreight")) { return new EcoFreightLabel(parcel); }
    if (carrier.equals("SameDay")) { return new SameDayLabel(parcel); }
    throw new IllegalArgumentException("No such carrier: " + carrier);
}

Pickup makePickup(String carrier) {
    if (carrier.equals("EcoFreight")) { return new CargoBikePickup(); }
    return new VanPickup();
}

// The same steps for every carrier: make its label, book its pickup.
String ship(Package parcel, String carrier) {
    Label label = makeLabel(carrier, parcel);
    Pickup pickup = makePickup(carrier);
    return carrier + ": label " + label.text() + ", pickup by " + pickup.text();
}

void main() {
    Package parcel = new Package(42);
    for (String carrier : List.of("QuickShip", "EcoFreight", "SameDay")) {
        IO.println(ship(parcel, carrier));
    }
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
class Package:
    def __init__(self, id):
        self.id = id


class QuickShipLabel:
    def __init__(self, parcel):
        self.text = f"QS-{parcel.id:04d}"


class EcoFreightLabel:
    def __init__(self, parcel):
        self.text = f"ECO{parcel.id}"


class SameDayLabel:
    def __init__(self, parcel):
        self.text = f"SD/{parcel.id}"


class VanPickup:
    text = "van"


class CargoBikePickup:
    text = "cargo bike"


class CourierPickup:
    text = "courier"


def make_label(carrier, parcel):
    if carrier == "QuickShip":
        return QuickShipLabel(parcel)
    if carrier == "EcoFreight":
        return EcoFreightLabel(parcel)
    if carrier == "SameDay":
        return SameDayLabel(parcel)
    raise ValueError(f"No such carrier: {carrier}")


def make_pickup(carrier):
    if carrier == "EcoFreight":
        return CargoBikePickup()
    return VanPickup()


def ship(parcel, carrier):
    """The same steps for every carrier: make its label, book its pickup."""
    label = make_label(carrier, parcel)
    pickup = make_pickup(carrier)
    return f"{carrier}: label {label.text}, pickup by {pickup.text}"


parcel = Package(42)
for carrier in ["QuickShip", "EcoFreight", "SameDay"]:
    print(ship(parcel, carrier))
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
class Package {
  constructor(id) {
    this.id = id;
  }
}

class QuickShipLabel { constructor(parcel) { this.text = `QS-${String(parcel.id).padStart(4, "0")}`; } }
class EcoFreightLabel { constructor(parcel) { this.text = `ECO${parcel.id}`; } }
class SameDayLabel { constructor(parcel) { this.text = `SD/${parcel.id}`; } }

class VanPickup { text = "van"; }
class CargoBikePickup { text = "cargo bike"; }
class CourierPickup { text = "courier"; }

function makeLabel(carrier, parcel) {
  if (carrier === "QuickShip") { return new QuickShipLabel(parcel); }
  if (carrier === "EcoFreight") { return new EcoFreightLabel(parcel); }
  if (carrier === "SameDay") { return new SameDayLabel(parcel); }
  throw new Error(`No such carrier: ${carrier}`);
}

function makePickup(carrier) {
  if (carrier === "EcoFreight") { return new CargoBikePickup(); }
  return new VanPickup();
}

// The same steps for every carrier: make its label, book its pickup.
function ship(parcel, carrier) {
  const label = makeLabel(carrier, parcel);
  const pickup = makePickup(carrier);
  return `${carrier}: label ${label.text}, pickup by ${pickup.text}`;
}

const parcel = new Package(42);
for (const carrier of ["QuickShip", "EcoFreight", "SameDay"]) {
  console.log(ship(parcel, carrier));
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
class Package {
  id: number;

  constructor(id: number) {
    this.id = id;
  }
}

interface Label { text: string; }
class QuickShipLabel implements Label { text: string; constructor(parcel: Package) { this.text = `QS-${String(parcel.id).padStart(4, "0")}`; } }
class EcoFreightLabel implements Label { text: string; constructor(parcel: Package) { this.text = `ECO${parcel.id}`; } }
class SameDayLabel implements Label { text: string; constructor(parcel: Package) { this.text = `SD/${parcel.id}`; } }

interface Pickup { text: string; }
class VanPickup implements Pickup { text = "van"; }
class CargoBikePickup implements Pickup { text = "cargo bike"; }
class CourierPickup implements Pickup { text = "courier"; }

function makeLabel(carrier: string, parcel: Package): Label {
  if (carrier === "QuickShip") { return new QuickShipLabel(parcel); }
  if (carrier === "EcoFreight") { return new EcoFreightLabel(parcel); }
  if (carrier === "SameDay") { return new SameDayLabel(parcel); }
  throw new Error(`No such carrier: ${carrier}`);
}

function makePickup(carrier: string): Pickup {
  if (carrier === "EcoFreight") { return new CargoBikePickup(); }
  return new VanPickup();
}

// The same steps for every carrier: make its label, book its pickup.
function ship(parcel: Package, carrier: string): string {
  const label = makeLabel(carrier, parcel);
  const pickup = makePickup(carrier);
  return `${carrier}: label ${label.text}, pickup by ${pickup.text}`;
}

const parcel = new Package(42);
for (const carrier of ["QuickShip", "EcoFreight", "SameDay"]) {
  console.log(ship(parcel, carrier));
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van

SameDay's package is waiting for a van that SameDay doesn't send. The person who added SameDay found MakeLabel, didn't know about MakePickup, and CourierPickup sits there, never used. It's Pass 1's smell again, one level up: Pass 1 copied one if chain into two screens; here two factories each keep their own if chain on the same carrier name.

  • The symptom: more than one simple factory switching on the same name, which all have to change together.
  • The cause: "which carrier is this?" is answered again in every factory, so a carrier's label and its pickup, which belong together, are made in two different places.

What would you try?

Add SameDay to MakePickup. That fixes today's van. The fourth carrier needs the same two edits, and the first time a third thing per carrier arrives (a customs form, say), it's three factories to keep in step.

One big factory that returns both, MakeLabelAndPickup(carrier). The two are made together now, which helps. But it's still one if chain on the carrier's name that every new carrier edits, and it grows with every new thing a carrier makes.

A dictionary from carrier name to label maker, and another to pickup maker. That's Pass 1's dictionary of functions, twice: two lists to keep in step instead of two if chains.

What would really help: decide "which carrier?" once, and from then on let the carrier itself make everything that's its own. Shipping should run the same steps and ask the carrier for a label and a pickup, without ever naming a class.

The everyday version: each carrier's own office

Imagine dropping a package at a shipping center where each carrier has its own counter. You hand it over and say "ship this". You don't say which label printer to use or which truck to call; each carrier's counter knows its own label and its own pickup. The center's routine is the same at every counter; what each one makes is its own.

A row of three shipping counters in one hall, each with its own sign, "QuickShip", "EcoFreight" and "SameDay", and each with its own clerk printing a label: behind the QuickShip counter a van waits at the loading door, behind EcoFreight a cargo bike, behind SameDay a courier with a shoulder bag

The fix: let each carrier decide

Give Ship a home in a base class, Carrier, and have it ask for what it needs through two methods it doesn't fill in itself, CreateLabel and CreatePickup. Each carrier is a subclass that overrides both. The shared steps never say new QuickShipLabel() again:

Factory Method's roles: the shipping steps, written once, ask "make me a label and a pickup". Each carrier is a kind of those steps with its own makers: QuickShip a QS label and a van, EcoFreight an ECO label and a cargo bike, SameDay an SD label and a courier, in a fence of what changes

How it got its name

A method whose only job is to make an object, which subclasses override to decide which class gets made, is a factory method, and the pattern is Factory Method, one of the two factory patterns in the original 1994 book. It's Template Method with a twist: the step each subclass fills in makes something. And Pass 1's simple factory doesn't disappear. It still picks the carrier once, by name, at the edge of the app; the factory methods take over from there.

The classic version

Package parcel = new Package(42);
foreach (string name in new List<string> { "QuickShip", "EcoFreight", "SameDay" })
{
    Console.WriteLine(MakeCarrier(name).Ship(parcel));
}

// Pass 1's simple factory, once: it picks the carrier by name. Everything after that is the carrier's decision.
Carrier MakeCarrier(string name)
{
    if (name == "QuickShip") { return new QuickShip(); }
    if (name == "EcoFreight") { return new EcoFreight(); }
    if (name == "SameDay") { return new SameDay(); }
    throw new ArgumentException("No such carrier: " + name);
}

abstract class Carrier
{
    public abstract string Name { get; }

    // The factory methods: each carrier decides which label and which pickup to make.
    protected abstract ILabel CreateLabel(Package parcel);
    protected abstract IPickup CreatePickup();

    // The same steps for every carrier, written once. They never name a label or pickup class.
    public string Ship(Package parcel)
    {
        ILabel label = CreateLabel(parcel);
        IPickup pickup = CreatePickup();
        return quot;{Name}: label {label.Text}, pickup by {pickup.Text}";
    }
}

class QuickShip : Carrier
{
    public override string Name => "QuickShip";
    protected override ILabel CreateLabel(Package parcel) => new QuickShipLabel(parcel);
    protected override IPickup CreatePickup() => new VanPickup();
}

class EcoFreight : Carrier
{
    public override string Name => "EcoFreight";
    protected override ILabel CreateLabel(Package parcel) => new EcoFreightLabel(parcel);
    protected override IPickup CreatePickup() => new CargoBikePickup();
}

class SameDay : Carrier
{
    public override string Name => "SameDay";
    protected override ILabel CreateLabel(Package parcel) => new SameDayLabel(parcel);
    protected override IPickup CreatePickup() => new CourierPickup();
}

record Package(int Id);

interface ILabel { string Text { get; } }
record QuickShipLabel(Package Parcel) : ILabel { public string Text => quot;QS-{Parcel.Id:D4}"; }
record EcoFreightLabel(Package Parcel) : ILabel { public string Text => quot;ECO{Parcel.Id}"; }
record SameDayLabel(Package Parcel) : ILabel { public string Text => quot;SD/{Parcel.Id}"; }

interface IPickup { string Text { get; } }
class VanPickup : IPickup { public string Text => "van"; }
class CargoBikePickup : IPickup { public string Text => "cargo bike"; }
class CourierPickup : IPickup { public string Text => "courier"; }
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
record Package(int id) {}

interface Label { String text(); }
record QuickShipLabel(Package parcel) implements Label { public String text() { return String.format("QS-%04d", parcel.id()); } }
record EcoFreightLabel(Package parcel) implements Label { public String text() { return "ECO" + parcel.id(); } }
record SameDayLabel(Package parcel) implements Label { public String text() { return "SD/" + parcel.id(); } }

interface Pickup { String text(); }
class VanPickup implements Pickup { public String text() { return "van"; } }
class CargoBikePickup implements Pickup { public String text() { return "cargo bike"; } }
class CourierPickup implements Pickup { public String text() { return "courier"; } }

abstract class Carrier {
    abstract String name();

    // The factory methods: each carrier decides which label and which pickup to make.
    abstract Label createLabel(Package parcel);
    abstract Pickup createPickup();

    // The same steps for every carrier, written once. They never name a label or pickup class.
    final String ship(Package parcel) {
        Label label = createLabel(parcel);
        Pickup pickup = createPickup();
        return name() + ": label " + label.text() + ", pickup by " + pickup.text();
    }
}

class QuickShip extends Carrier {
    String name() { return "QuickShip"; }
    Label createLabel(Package parcel) { return new QuickShipLabel(parcel); }
    Pickup createPickup() { return new VanPickup(); }
}

class EcoFreight extends Carrier {
    String name() { return "EcoFreight"; }
    Label createLabel(Package parcel) { return new EcoFreightLabel(parcel); }
    Pickup createPickup() { return new CargoBikePickup(); }
}

class SameDay extends Carrier {
    String name() { return "SameDay"; }
    Label createLabel(Package parcel) { return new SameDayLabel(parcel); }
    Pickup createPickup() { return new CourierPickup(); }
}

// Pass 1's simple factory, once: it picks the carrier by name. Everything after that is the carrier's decision.
Carrier makeCarrier(String name) {
    if (name.equals("QuickShip")) { return new QuickShip(); }
    if (name.equals("EcoFreight")) { return new EcoFreight(); }
    if (name.equals("SameDay")) { return new SameDay(); }
    throw new IllegalArgumentException("No such carrier: " + name);
}

void main() {
    Package parcel = new Package(42);
    for (String name : List.of("QuickShip", "EcoFreight", "SameDay")) {
        IO.println(makeCarrier(name).ship(parcel));
    }
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
from abc import ABC, abstractmethod


class Package:
    def __init__(self, id):
        self.id = id


class QuickShipLabel:
    def __init__(self, parcel):
        self.text = f"QS-{parcel.id:04d}"


class EcoFreightLabel:
    def __init__(self, parcel):
        self.text = f"ECO{parcel.id}"


class SameDayLabel:
    def __init__(self, parcel):
        self.text = f"SD/{parcel.id}"


class VanPickup:
    text = "van"


class CargoBikePickup:
    text = "cargo bike"


class CourierPickup:
    text = "courier"


class Carrier(ABC):
    name = ""

    # The factory methods: each carrier decides which label and which pickup to make.
    @abstractmethod
    def create_label(self, parcel):
        ...

    @abstractmethod
    def create_pickup(self):
        ...

    def ship(self, parcel):
        """The same steps for every carrier, written once. They never name a label or pickup class."""
        label = self.create_label(parcel)
        pickup = self.create_pickup()
        return f"{self.name}: label {label.text}, pickup by {pickup.text}"


class QuickShip(Carrier):
    name = "QuickShip"

    def create_label(self, parcel):
        return QuickShipLabel(parcel)

    def create_pickup(self):
        return VanPickup()


class EcoFreight(Carrier):
    name = "EcoFreight"

    def create_label(self, parcel):
        return EcoFreightLabel(parcel)

    def create_pickup(self):
        return CargoBikePickup()


class SameDay(Carrier):
    name = "SameDay"

    def create_label(self, parcel):
        return SameDayLabel(parcel)

    def create_pickup(self):
        return CourierPickup()


def make_carrier(name):
    """Pass 1's simple factory, once: it picks the carrier by name. Everything after that is the carrier's decision."""
    if name == "QuickShip":
        return QuickShip()
    if name == "EcoFreight":
        return EcoFreight()
    if name == "SameDay":
        return SameDay()
    raise ValueError(f"No such carrier: {name}")


parcel = Package(42)
for name in ["QuickShip", "EcoFreight", "SameDay"]:
    print(make_carrier(name).ship(parcel))
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
class Package {
  constructor(id) {
    this.id = id;
  }
}

class QuickShipLabel { constructor(parcel) { this.text = `QS-${String(parcel.id).padStart(4, "0")}`; } }
class EcoFreightLabel { constructor(parcel) { this.text = `ECO${parcel.id}`; } }
class SameDayLabel { constructor(parcel) { this.text = `SD/${parcel.id}`; } }

class VanPickup { text = "van"; }
class CargoBikePickup { text = "cargo bike"; }
class CourierPickup { text = "courier"; }

class Carrier {
  // The factory methods: each carrier decides which label and which pickup to make.
  createLabel(parcel) { throw new Error("Each carrier makes its own label"); }
  createPickup() { throw new Error("Each carrier books its own pickup"); }

  // The same steps for every carrier, written once. They never name a label or pickup class.
  ship(parcel) {
    const label = this.createLabel(parcel);
    const pickup = this.createPickup();
    return `${this.name}: label ${label.text}, pickup by ${pickup.text}`;
  }
}

class QuickShip extends Carrier {
  name = "QuickShip";
  createLabel(parcel) { return new QuickShipLabel(parcel); }
  createPickup() { return new VanPickup(); }
}

class EcoFreight extends Carrier {
  name = "EcoFreight";
  createLabel(parcel) { return new EcoFreightLabel(parcel); }
  createPickup() { return new CargoBikePickup(); }
}

class SameDay extends Carrier {
  name = "SameDay";
  createLabel(parcel) { return new SameDayLabel(parcel); }
  createPickup() { return new CourierPickup(); }
}

// Pass 1's simple factory, once: it picks the carrier by name. Everything after that is the carrier's decision.
function makeCarrier(name) {
  if (name === "QuickShip") { return new QuickShip(); }
  if (name === "EcoFreight") { return new EcoFreight(); }
  if (name === "SameDay") { return new SameDay(); }
  throw new Error(`No such carrier: ${name}`);
}

const parcel = new Package(42);
for (const name of ["QuickShip", "EcoFreight", "SameDay"]) {
  console.log(makeCarrier(name).ship(parcel));
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
class Package {
  id: number;

  constructor(id: number) {
    this.id = id;
  }
}

interface Label { text: string; }
class QuickShipLabel implements Label { text: string; constructor(parcel: Package) { this.text = `QS-${String(parcel.id).padStart(4, "0")}`; } }
class EcoFreightLabel implements Label { text: string; constructor(parcel: Package) { this.text = `ECO${parcel.id}`; } }
class SameDayLabel implements Label { text: string; constructor(parcel: Package) { this.text = `SD/${parcel.id}`; } }

interface Pickup { text: string; }
class VanPickup implements Pickup { text = "van"; }
class CargoBikePickup implements Pickup { text = "cargo bike"; }
class CourierPickup implements Pickup { text = "courier"; }

abstract class Carrier {
  abstract name: string;

  // The factory methods: each carrier decides which label and which pickup to make.
  abstract createLabel(parcel: Package): Label;
  abstract createPickup(): Pickup;

  // The same steps for every carrier, written once. They never name a label or pickup class.
  ship(parcel: Package): string {
    const label = this.createLabel(parcel);
    const pickup = this.createPickup();
    return `${this.name}: label ${label.text}, pickup by ${pickup.text}`;
  }
}

class QuickShip extends Carrier {
  name = "QuickShip";
  createLabel(parcel: Package): Label { return new QuickShipLabel(parcel); }
  createPickup(): Pickup { return new VanPickup(); }
}

class EcoFreight extends Carrier {
  name = "EcoFreight";
  createLabel(parcel: Package): Label { return new EcoFreightLabel(parcel); }
  createPickup(): Pickup { return new CargoBikePickup(); }
}

class SameDay extends Carrier {
  name = "SameDay";
  createLabel(parcel: Package): Label { return new SameDayLabel(parcel); }
  createPickup(): Pickup { return new CourierPickup(); }
}

// Pass 1's simple factory, once: it picks the carrier by name. Everything after that is the carrier's decision.
function makeCarrier(name: string): Carrier {
  if (name === "QuickShip") { return new QuickShip(); }
  if (name === "EcoFreight") { return new EcoFreight(); }
  if (name === "SameDay") { return new SameDay(); }
  throw new Error(`No such carrier: ${name}`);
}

const parcel = new Package(42);
for (const name of ["QuickShip", "EcoFreight", "SameDay"]) {
  console.log(makeCarrier(name).ship(parcel));
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier

SameDay's courier shows up now. Ship names no label or pickup class at all, and there's one if chain left, in MakeCarrier, deciding which carrier once. A fourth carrier is one subclass that makes its own label and its own pickup, together, plus one line in MakeCarrier. And the abstract methods mean a carrier that forgets its pickup doesn't compile in C#, Java and TypeScript, and can't be made in Python.

Where the languages differ. As in Template Method, C#, Java and TypeScript mark the factory methods abstract, Python uses ABC and @abstractmethod, and JavaScript's base class throws a clear error. Java marks ship final so no carrier can change the steps.

The modern version: hand in the makers

The same carriers, without subclasses: one Carrier class, handed a function that makes its label and one that makes its pickup, kept in a dictionary by name as in Pass 1's Factories the Modern Way:

Package parcel = new Package(42);
Dictionary<string, Carrier> carriers = new Dictionary<string, Carrier>
{
    ["QuickShip"] = new Carrier("QuickShip", p => new QuickShipLabel(p), () => new VanPickup()),
    ["EcoFreight"] = new Carrier("EcoFreight", p => new EcoFreightLabel(p), () => new CargoBikePickup()),
    ["SameDay"] = new Carrier("SameDay", p => new SameDayLabel(p), () => new CourierPickup())
};
foreach (string name in new List<string> { "QuickShip", "EcoFreight", "SameDay" })
{
    Console.WriteLine(carriers[name].Ship(parcel));
}

class Carrier
{
    private readonly string name;
    private readonly Func<Package, ILabel> createLabel;
    private readonly Func<IPickup> createPickup;

    public Carrier(string name, Func<Package, ILabel> createLabel, Func<IPickup> createPickup)
    {
        this.name = name;
        this.createLabel = createLabel;
        this.createPickup = createPickup;
    }

    public string Ship(Package parcel)
    {
        ILabel label = createLabel(parcel);
        IPickup pickup = createPickup();
        return quot;{name}: label {label.Text}, pickup by {pickup.Text}";
    }
}

record Package(int Id);

interface ILabel { string Text { get; } }
record QuickShipLabel(Package Parcel) : ILabel { public string Text => quot;QS-{Parcel.Id:D4}"; }
record EcoFreightLabel(Package Parcel) : ILabel { public string Text => quot;ECO{Parcel.Id}"; }
record SameDayLabel(Package Parcel) : ILabel { public string Text => quot;SD/{Parcel.Id}"; }

interface IPickup { string Text { get; } }
class VanPickup : IPickup { public string Text => "van"; }
class CargoBikePickup : IPickup { public string Text => "cargo bike"; }
class CourierPickup : IPickup { public string Text => "courier"; }
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
record Package(int id) {}

interface Label { String text(); }
record QuickShipLabel(Package parcel) implements Label { public String text() { return String.format("QS-%04d", parcel.id()); } }
record EcoFreightLabel(Package parcel) implements Label { public String text() { return "ECO" + parcel.id(); } }
record SameDayLabel(Package parcel) implements Label { public String text() { return "SD/" + parcel.id(); } }

interface Pickup { String text(); }
class VanPickup implements Pickup { public String text() { return "van"; } }
class CargoBikePickup implements Pickup { public String text() { return "cargo bike"; } }
class CourierPickup implements Pickup { public String text() { return "courier"; } }

// A carrier is handed its makers. QuickShipLabel::new is a reference to the constructor itself.
record Carrier(String name, Function<Package, Label> createLabel, Supplier<Pickup> createPickup) {
    String ship(Package parcel) {
        Label label = createLabel.apply(parcel);
        Pickup pickup = createPickup.get();
        return name + ": label " + label.text() + ", pickup by " + pickup.text();
    }
}

void main() {
    Package parcel = new Package(42);
    Map<String, Carrier> carriers = Map.of(
        "QuickShip", new Carrier("QuickShip", QuickShipLabel::new, VanPickup::new),
        "EcoFreight", new Carrier("EcoFreight", EcoFreightLabel::new, CargoBikePickup::new),
        "SameDay", new Carrier("SameDay", SameDayLabel::new, CourierPickup::new));
    for (String name : List.of("QuickShip", "EcoFreight", "SameDay")) {
        IO.println(carriers.get(name).ship(parcel));
    }
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
class Package:
    def __init__(self, id):
        self.id = id


class QuickShipLabel:
    def __init__(self, parcel):
        self.text = f"QS-{parcel.id:04d}"


class EcoFreightLabel:
    def __init__(self, parcel):
        self.text = f"ECO{parcel.id}"


class SameDayLabel:
    def __init__(self, parcel):
        self.text = f"SD/{parcel.id}"


class VanPickup:
    text = "van"


class CargoBikePickup:
    text = "cargo bike"


class CourierPickup:
    text = "courier"


class Carrier:
    def __init__(self, name, create_label, create_pickup):
        self.name = name
        self.create_label = create_label
        self.create_pickup = create_pickup

    def ship(self, parcel):
        label = self.create_label(parcel)
        pickup = self.create_pickup()
        return f"{self.name}: label {label.text}, pickup by {pickup.text}"


# A class is already a function that makes an object, so the classes themselves are the makers.
carriers = {
    "QuickShip": Carrier("QuickShip", QuickShipLabel, VanPickup),
    "EcoFreight": Carrier("EcoFreight", EcoFreightLabel, CargoBikePickup),
    "SameDay": Carrier("SameDay", SameDayLabel, CourierPickup),
}
parcel = Package(42)
for name in ["QuickShip", "EcoFreight", "SameDay"]:
    print(carriers[name].ship(parcel))
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
class Package {
  constructor(id) {
    this.id = id;
  }
}

class QuickShipLabel { constructor(parcel) { this.text = `QS-${String(parcel.id).padStart(4, "0")}`; } }
class EcoFreightLabel { constructor(parcel) { this.text = `ECO${parcel.id}`; } }
class SameDayLabel { constructor(parcel) { this.text = `SD/${parcel.id}`; } }

class VanPickup { text = "van"; }
class CargoBikePickup { text = "cargo bike"; }
class CourierPickup { text = "courier"; }

class Carrier {
  constructor(name, createLabel, createPickup) {
    this.name = name;
    this.createLabel = createLabel;
    this.createPickup = createPickup;
  }

  ship(parcel) {
    const label = this.createLabel(parcel);
    const pickup = this.createPickup();
    return `${this.name}: label ${label.text}, pickup by ${pickup.text}`;
  }
}

const carriers = new Map([
  ["QuickShip", new Carrier("QuickShip", (p) => new QuickShipLabel(p), () => new VanPickup())],
  ["EcoFreight", new Carrier("EcoFreight", (p) => new EcoFreightLabel(p), () => new CargoBikePickup())],
  ["SameDay", new Carrier("SameDay", (p) => new SameDayLabel(p), () => new CourierPickup())],
]);
const parcel = new Package(42);
for (const name of ["QuickShip", "EcoFreight", "SameDay"]) {
  console.log(carriers.get(name).ship(parcel));
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
class Package {
  id: number;

  constructor(id: number) {
    this.id = id;
  }
}

interface Label { text: string; }
class QuickShipLabel implements Label { text: string; constructor(parcel: Package) { this.text = `QS-${String(parcel.id).padStart(4, "0")}`; } }
class EcoFreightLabel implements Label { text: string; constructor(parcel: Package) { this.text = `ECO${parcel.id}`; } }
class SameDayLabel implements Label { text: string; constructor(parcel: Package) { this.text = `SD/${parcel.id}`; } }

interface Pickup { text: string; }
class VanPickup implements Pickup { text = "van"; }
class CargoBikePickup implements Pickup { text = "cargo bike"; }
class CourierPickup implements Pickup { text = "courier"; }

class Carrier {
  name: string;
  createLabel: (parcel: Package) => Label;
  createPickup: () => Pickup;

  constructor(name: string, createLabel: (parcel: Package) => Label, createPickup: () => Pickup) {
    this.name = name;
    this.createLabel = createLabel;
    this.createPickup = createPickup;
  }

  ship(parcel: Package): string {
    const label = this.createLabel(parcel);
    const pickup = this.createPickup();
    return `${this.name}: label ${label.text}, pickup by ${pickup.text}`;
  }
}

const carriers = new Map<string, Carrier>([
  ["QuickShip", new Carrier("QuickShip", (p) => new QuickShipLabel(p), () => new VanPickup())],
  ["EcoFreight", new Carrier("EcoFreight", (p) => new EcoFreightLabel(p), () => new CargoBikePickup())],
  ["SameDay", new Carrier("SameDay", (p) => new SameDayLabel(p), () => new CourierPickup())],
]);
const parcel = new Package(42);
for (const name of ["QuickShip", "EcoFreight", "SameDay"]) {
  console.log(carriers.get(name)!.ship(parcel));
}
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier

Same three lines, no subclasses. Each carrier's label maker and pickup maker are handed in together, on one line, so they can't drift apart the way two factories did. Java can hand over a constructor itself (QuickShipLabel::new), and in Python a class is the function that makes one.

Where you've already used it

  • iterator() in Java, GetEnumerator() in C#, __iter__ in Python: every collection class overrides one method to make its own kind of iterator, and for-each calls it without knowing which. That's a factory method, and it's this chapter's Iterator lesson seen from the other side.
  • Test frameworks that let a test class override a "create the object under test" method, so the shared test steps run against whichever object each subclass makes.
  • UI frameworks whose base window or page class calls a "create the content" method you override.

When not to use it

  • When there's one kind. One carrier needs no factory method; new is fine.
  • When nothing else varies by subclass. If a carrier subclass would exist only to make one object, handing in the maker, as in the modern version, is less code.
  • When the object only needs picking by name, once. That's Pass 1's simple factory, and it's still the right tool.

The cost: a subclass per carrier, and a reader who wants to know what Ship makes has to look in the subclass.

Look-alikes: Simple Factory picks a class from a name in one function; Factory Method lets subclasses decide inside shared steps; Abstract Factory, in Pass 3, makes a whole matched family from one object. A later lesson, Choosing a Creational Pattern, compares them in one table.

How often you'll meet it: now and then in app code; every day inside frameworks and collection classes (our estimate).

Check yourself

2 questions to try on the lesson page.

So what

When two simple factories switch on the same name, decide the name once and let the thing you picked make everything that's its own. Shared steps that never name a concrete class are steps a new carrier can't break.

Key terms

Cheat sheets