What It Is
The Factory Method pattern puts the creation of an object behind a function. The caller says what it wants — the factory decides which concrete class to build and returns it as an interface.
The caller never touches the concrete classes, so new kinds can be added without changing any calling code. In PHP this is simply a newSomething() function — or a static method on a class — that returns an interface.
Example: A Storage Factory
newStorage("disk") and newStorage("memory") return different concrete classes behind the same Storage interface — the caller cannot tell the difference, and does not need to.
The factory picks the class
The match over kinds lives in one place — the factory. The rest of the program only knows the interface.
Output: PHP script
<?php
interface Storage {
public function save(string $data): string;
}
class DiskStore implements Storage {
public function save(string $data): string {
return "disk: saved " . $data;
}
}
class MemoryStore implements Storage {
public function save(string $data): string {
return "memory: kept " . $data;
}
}
// The factory decides which concrete class to build.
function newStorage(string $kind): Storage {
return match ($kind) {
"memory" => new MemoryStore(),
default => new DiskStore(),
};
}
foreach (["disk", "memory"] as $kind) {
$s = newStorage($kind);
echo $s->save("order #1042"), "\n";
}
When to Use It
Use it when the concrete class depends on something known only at run time — a config value, a user choice, an environment — or when you want creation logic in exactly one place.
Skip it when there is only one implementation and no sign of a second. $store = new DiskStore() needs no factory.
Pros and Cons
Pros: creation logic in one place; callers depend only on the interface; adding a kind touches only the factory.
Cons: one more layer to read through; with a single implementation it is pure ceremony.