Factory Pattern · Design Patterns

What is the Factory pattern?

Factory means: one place builds your objects, and callers just say what kind they want.

You do not scatter type checks or new calls across the app. You ask a factory for “a payment of this kind,” and it decides which concrete class to build.

To build it you usually:

Hide the decision in one function or class.
Return a shared interface, not the concrete type.
Let new kinds plug in without editing old code.

The problem it solves

Without a factory, the same type check gets copied into every screen that needs a payment object.

if kind == "card":
    payment = CardPayment()
elif kind == "wallet":
    payment = WalletPayment()
else:
    raise ValueError(f"Unknown: {kind}")

Payment payment;
if (kind.equals("card")) {
    payment = new CardPayment();
} else if (kind.equals("wallet")) {
    payment = new WalletPayment();
} else {
    throw new IllegalArgumentException("Unknown: " + kind);
}

var payment Payment
switch kind {
case "card":
	payment = CardPayment{}
case "wallet":
	payment = WalletPayment{}
default:
	panic("unknown kind: " + kind)
}

let payment: Payment;
if (kind === 'card') {
  payment = new CardPayment();
} else if (kind === 'wallet') {
  payment = new WalletPayment();
} else {
  throw new Error(`Unknown: ${kind}`);
}

Add a new payment method, and now you hunt through checkout, refunds, and the admin screen for every copy of that check.

You want one place that decides, and everyone else just asks.

Simple factory: one function, one decision

The smallest version is one function that takes a kind and returns the right object.

class Payment:
    def charge(self, amount: float) -> str:
        raise NotImplementedError

class CardPayment(Payment):
    def charge(self, amount: float) -> str:
        return f"Charged {amount} via card"

class WalletPayment(Payment):
    def charge(self, amount: float) -> str:
        return f"Charged {amount} via wallet"

def create_payment(kind: str) -> Payment:
    if kind == "card":
        return CardPayment()
    elif kind == "wallet":
        return WalletPayment()
    raise ValueError(f"Unknown kind: {kind}")

# use
payment = create_payment("card")
print(payment.charge(42.5))

public interface Payment {
    String charge(double amount);
}

public class CardPayment implements Payment {
    public String charge(double amount) {
        return "Charged " + amount + " via card";
    }
}

public class WalletPayment implements Payment {
    public String charge(double amount) {
        return "Charged " + amount + " via wallet";
    }
}

public class PaymentFactory {
    public Payment create(String kind) {
        if (kind.equals("card")) {
            return new CardPayment();
        } else if (kind.equals("wallet")) {
            return new WalletPayment();
        }
        throw new IllegalArgumentException("Unknown kind: " + kind);
    }
}

// use
Payment payment = new PaymentFactory().create("card");
System.out.println(payment.charge(42.5));

package payment

import "fmt"

type Payment interface {
	Charge(amount float64) string
}

type CardPayment struct{}

func (CardPayment) Charge(amount float64) string {
	return fmt.Sprintf("Charged %.2f via card", amount)
}

type WalletPayment struct{}

func (WalletPayment) Charge(amount float64) string {
	return fmt.Sprintf("Charged %.2f via wallet", amount)
}

func Create(kind string) (Payment, error) {
	switch kind {
	case "card":
		return CardPayment{}, nil
	case "wallet":
		return WalletPayment{}, nil
	default:
		return nil, fmt.Errorf("unknown kind: %s", kind)
	}
}

// use
// p, _ := payment.Create("card")
// fmt.Println(p.Charge(42.5))

interface Payment {
  charge(amount: number): string;
}

class CardPayment implements Payment {
  charge(amount: number) {
    return `Charged ${amount} via card`;
  }
}

class WalletPayment implements Payment {
  charge(amount: number) {
    return `Charged ${amount} via wallet`;
  }
}

function createPayment(kind: string): Payment {
  if (kind === 'card') return new CardPayment();
  if (kind === 'wallet') return new WalletPayment();
  throw new Error(`Unknown kind: ${kind}`);
}

// use
const payment = createPayment('card');
console.log(payment.charge(42.5));

This is not one of the original design patterns — just good hygiene. One place knows how to build a Payment; everyone else just calls it.

Factory Method: let subtypes decide

The simple factory still has one if/switch someone edits for every new kind. Factory Method moves that decision into subtypes instead, using overriding rather than conditionals.

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def create_payment(self) -> Payment:
        ...

    def process_order(self, amount: float) -> None:
        payment = self.create_payment()
        print(payment.charge(amount))

class CardProcessor(PaymentProcessor):
    def create_payment(self) -> Payment:
        return CardPayment()

class WalletProcessor(PaymentProcessor):
    def create_payment(self) -> Payment:
        return WalletPayment()

# use
processor = CardProcessor()
processor.process_order(42.5)

public abstract class PaymentProcessor {
    public abstract Payment createPayment();

    public void processOrder(double amount) {
        Payment payment = createPayment();
        System.out.println(payment.charge(amount));
    }
}

public class CardProcessor extends PaymentProcessor {
    public Payment createPayment() {
        return new CardPayment();
    }
}

public class WalletProcessor extends PaymentProcessor {
    public Payment createPayment() {
        return new WalletPayment();
    }
}

// use
PaymentProcessor processor = new CardProcessor();
processor.processOrder(42.5);

package payment

import "fmt"

type Processor interface {
	CreatePayment() Payment
}

type CardProcessor struct{}

func (CardProcessor) CreatePayment() Payment {
	return CardPayment{}
}

type WalletProcessor struct{}

func (WalletProcessor) CreatePayment() Payment {
	return WalletPayment{}
}

func ProcessOrder(p Processor, amount float64) {
	payment := p.CreatePayment()
	fmt.Println(payment.Charge(amount))
}

// use
// ProcessOrder(CardProcessor{}, 42.5)

abstract class PaymentProcessor {
  abstract createPayment(): Payment;

  processOrder(amount: number) {
    const payment = this.createPayment();
    console.log(payment.charge(amount));
  }
}

class CardProcessor extends PaymentProcessor {
  createPayment() {
    return new CardPayment();
  }
}

class WalletProcessor extends PaymentProcessor {
  createPayment() {
    return new WalletPayment();
  }
}

// use
const processor = new CardProcessor();
processor.processOrder(42.5);

Now there is no if/else anywhere. Adding a new kind means adding a new subtype, not editing old code.

Registry-based factory: the practical default

A registry-based factory keeps a lookup from “kind” to “implementation” and just reads from it at runtime. Each implementation reports its own kind, so the factory never needs to know every concrete type up front.

class PaymentProcessor:
    kind: str

    def process(self, amount: float) -> None:
        raise NotImplementedError

class CardProcessor(PaymentProcessor):
    kind = "card"

    def process(self, amount: float) -> None:
        print(f"Processing card payment: {amount}")

class WalletProcessor(PaymentProcessor):
    kind = "wallet"

    def process(self, amount: float) -> None:
        print(f"Processing wallet payment: {amount}")

class PaymentProcessorFactory:
    def __init__(self, processors: list[PaymentProcessor]) -> None:
        self._processors = {p.kind: p for p in processors}

    def get(self, kind: str) -> PaymentProcessor:
        try:
            return self._processors[kind]
        except KeyError:
            raise ValueError(f"No processor for: {kind}")

# use
factory = PaymentProcessorFactory([CardProcessor(), WalletProcessor()])
factory.get("card").process(42.5)

public interface PaymentProcessor {
    void process(double amount);
    String getKind();
}

public class CardProcessor implements PaymentProcessor {
    public String getKind() { return "card"; }
    public void process(double amount) {
        System.out.println("Processing card payment: " + amount);
    }
}

public class WalletProcessor implements PaymentProcessor {
    public String getKind() { return "wallet"; }
    public void process(double amount) {
        System.out.println("Processing wallet payment: " + amount);
    }
}

public class PaymentProcessorFactory {
    private final Map<String, PaymentProcessor> processors = new HashMap<>();

    public PaymentProcessorFactory(List<PaymentProcessor> all) {
        for (PaymentProcessor p : all) {
            processors.put(p.getKind(), p);
        }
    }

    public PaymentProcessor get(String kind) {
        PaymentProcessor p = processors.get(kind);
        if (p == null) {
            throw new IllegalArgumentException("No processor for: " + kind);
        }
        return p;
    }
}

// use
PaymentProcessorFactory factory =
    new PaymentProcessorFactory(List.of(new CardProcessor(), new WalletProcessor()));
factory.get("card").process(42.5);

package payment

import "fmt"

type Processor interface {
	Process(amount float64)
}

type CardProcessor struct{}

func (CardProcessor) Process(amount float64) {
	fmt.Println("Processing card payment:", amount)
}

type WalletProcessor struct{}

func (WalletProcessor) Process(amount float64) {
	fmt.Println("Processing wallet payment:", amount)
}

var registry = map[string]Processor{
	"card":   CardProcessor{},
	"wallet": WalletProcessor{},
}

func Get(kind string) (Processor, error) {
	p, ok := registry[kind]
	if !ok {
		return nil, fmt.Errorf("no processor for: %s", kind)
	}
	return p, nil
}

// use
// p, _ := payment.Get("card")
// p.Process(42.5)

interface PaymentProcessor {
  kind: string;
  process(amount: number): void;
}

class CardProcessor implements PaymentProcessor {
  kind = 'card';
  process(amount: number) {
    console.log(`Processing card payment: ${amount}`);
  }
}

class WalletProcessor implements PaymentProcessor {
  kind = 'wallet';
  process(amount: number) {
    console.log(`Processing wallet payment: ${amount}`);
  }
}

class PaymentProcessorFactory {
  private processors = new Map<string, PaymentProcessor>();

  constructor(all: PaymentProcessor[]) {
    for (const p of all) this.processors.set(p.kind, p);
  }

  get(kind: string) {
    const p = this.processors.get(kind);
    if (!p) throw new Error(`No processor for: ${kind}`);
    return p;
  }
}

// use
const factory = new PaymentProcessorFactory([new CardProcessor(), new WalletProcessor()]);
factory.get('card').process(42.5);

Adding a crypto processor later means writing one new class and registering it — nothing above changes.

When it helps

Use Factory when the exact type depends on something you only know at runtime — a string from a request, a flag on an order — and there is more than one implementation callers should not need to tell apart.

Ask: “If a new kind shows up next year, how many files change?” With a good factory, the answer is one new file.

When it hurts

Do not wrap a single class in a factory. new CardPayment() is already clear — factory.createPayment() just adds a hop with nothing to hide.

Watch out for a factory that grows its own if/else chain as new types show up. That is a sign to move to a registry.

Practical tips

Start with a simple factory for a small, stable set of types.
Use Factory Method when subclasses each build their own related object.
Use a registry once the set of types keeps growing.
Always return the interface, never the concrete type.
Fail loudly on an unknown kind — never return null silently.

Check your understanding

Factory in one line?
One place builds objects; callers just name the kind they want.

Simple factory vs Factory Method?
Simple factory is one if/switch. Factory Method pushes the choice into subclasses, no conditionals.

Why is a registry the practical default?
New kinds register themselves. The factory code never needs to change.

Main risk of overusing Factory?
Wrapping a single implementation in a factory adds a hop that hides nothing.

What to learn next

Next: Builder Pattern — assemble a complex object step by step, then produce the finished result.