# 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 November 17, 2026

By Gregor Dzierzon

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

```csharp
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 $"{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 => $"QS-{Parcel.Id:D4}"; }
record EcoFreightLabel(Package Parcel) : ILabel { public string Text => $"ECO{Parcel.Id}"; }
record SameDayLabel(Package Parcel) : ILabel { public string Text => $"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"; }
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
```

```java
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));
    }
}
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
```

```python
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))
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
```

```javascript
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));
}
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by van
```

```typescript
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));
}
```

```text
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](https://fsdtrainingmedia.blob.core.windows.net/public/images/2026/11/01938313d96c4ce3b27ee5554ebe6a59.webp)

## 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](https://fsdtrainingmedia.blob.core.windows.net/public/images/2026/11/25d5f9a95e734f5a98e3b8eb3ee8c9b3.webp)

## 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

```csharp
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 $"{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 => $"QS-{Parcel.Id:D4}"; }
record EcoFreightLabel(Package Parcel) : ILabel { public string Text => $"ECO{Parcel.Id}"; }
record SameDayLabel(Package Parcel) : ILabel { public string Text => $"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"; }
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```java
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));
    }
}
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```python
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))
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```javascript
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));
}
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```typescript
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));
}
```

```text
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*:

```csharp
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 $"{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 => $"QS-{Parcel.Id:D4}"; }
record EcoFreightLabel(Package Parcel) : ILabel { public string Text => $"ECO{Parcel.Id}"; }
record SameDayLabel(Package Parcel) : ILabel { public string Text => $"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"; }
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```java
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));
    }
}
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```python
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))
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```javascript
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));
}
```

```text
QuickShip: label QS-0042, pickup by van
EcoFreight: label ECO42, pickup by cargo bike
SameDay: label SD/42, pickup by courier
```

```typescript
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));
}
```

```text
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

- [Factory Method](https://www.ask-codey.com/glossary/factory-method)
- [Simple Factory](https://www.ask-codey.com/glossary/simple-factory)
- [Code Smell](https://www.ask-codey.com/glossary/code-smell)

## Cheat sheets

- [Factory Method: Let Each Carrier Decide](https://www.ask-codey.com/cheat-sheets/dp-factory-method-cheat-sheet)

Source: https://www.ask-codey.com/lessons/dp-factory-method
