Skip to main content

​
Real-World Example

Consider, you are building a house and you need doors. You can either put on your carpenter clothes, bring some wood, glue, nails and all the tools required to build the door and start building it in your house or you can simply call the factory and get the built door delivered to you so that you don’t need to learn anything about the door making or to deal with the mess that comes with making it.

​
In Plain Words

Simple factory simply generates an instance for client without exposing any instantiation logic to the client.

​
Wikipedia Says

In object-oriented programming (OOP), a factory is an object for creating other objects – formally a factory is a function or method that returns objects of a varying prototype or class from some method call, which is assumed to be “new”.

​
Programmatic Example

First of all we have a door interface and the implementation: 
interface Door
{
    public function getWidth(): float;
    public function getHeight(): float;
}

class WoodenDoor implements Door
{
    protected $width;
    protected $height;

    public function __construct(float $width, float $height)
    {
        $this->width = $width;
        $this->height = $height;
    }

    public function getWidth(): float
    {
        return $this->width;
    }

    public function getHeight(): float
    {
        return $this->height;
    }
}
Then we have our door factory that makes the door and returns it: 
class DoorFactory
{
    public static function makeDoor($width, $height): Door
    {
        return new WoodenDoor($width, $height);
    }
}
And then it can be used as: 
// Make me a door of 100x200
$door = DoorFactory::makeDoor(100, 200);

echo 'Width: ' . $door->getWidth();
echo 'Height: ' . $door->getHeight();

// Make me a door of 50x100
$door2 = DoorFactory::makeDoor(50, 100);

​
When to Use?

When creating an object is not just a few assignments and involves some logic, it makes sense to put it in a dedicated factory instead of repeating the same code everywhere.
If the instantiation process is complex or requires configuration, a simple factory can encapsulate this complexity and provide a clean interface to clients.
The Simple Factory pattern is particularly useful when you have multiple places in your code that need to create the same type of object with similar initialization logic.

Build docs developers (and LLMs) love

Get started for freeTalk to us