Creational Design Patterns

Creational design patterns deal with object creation mechanisms – how objects are instantiated in a way that is flexible and reusable. They help make a system independent of how its objects are created, composed, and represented.

Here are the most popular creational design patterns with simple examples:

---

1. Singleton Pattern

Ensures that a class has only one instance and provides a global point of access to it.

✅ Use when you need only one instance (like DB connection, Logger, Config).

Example (PHP):

class Database {
    private static ?Database $instance = null;
    private function __construct() {
        echo "DB Connection Created\n";
    }

    public static function getInstance(): Database {
        if (self::$instance === null) {
            self::$instance = new Database();
        }
        return self::$instance;
    }
}

// Usage
$db1 = Database::getInstance();
$db2 = Database::getInstance();

var_dump($db1 === $db2); // true

---

2. Factory Method Pattern

Defines an interface for creating an object but lets subclasses alter the type of objects that will be created.

✅ Use when the exact object type isn’t known until runtime.

Example (PHP):

interface Product {
    public function getName(): string;
}

class Book implements Product {
    public function getName(): string {
        return "Book";
    }
}

class Pen implements Product {
    public function getName(): string {
        return "Pen";
    }
}

class ProductFactory {
    public static function create(string $type): Product {
        return match($type) {
            'book' => new Book(),
            'pen' => new Pen(),
            default => throw new Exception("Unknown product"),
        };
    }
}

// Usage
$product = ProductFactory::create('book');
echo $product->getName(); // Book

---

3. Abstract Factory Pattern

Provides an interface for creating families of related objects without specifying their concrete classes.

✅ Use when you want to create related products together.

Example (PHP):

// Abstract product interfaces
interface Button { public function render(): string; }
interface Checkbox { public function check(): string; }

// Concrete products
class WinButton implements Button { public function render(): string { return "Windows Button"; } }
class WinCheckbox implements Checkbox { public function check(): string { return "Windows Checkbox"; } }

class MacButton implements Button { public function render(): string { return "Mac Button"; } }
class MacCheckbox implements Checkbox { public function check(): string { return "Mac Checkbox"; } }

// Abstract Factory
interface GUIFactory {
    public function createButton(): Button;
    public function createCheckbox(): Checkbox;
}

// Concrete Factories
class WinFactory implements GUIFactory {
    public function createButton(): Button { return new WinButton(); }
    public function createCheckbox(): Checkbox { return new WinCheckbox(); }
}
class MacFactory implements GUIFactory {
    public function createButton(): Button { return new MacButton(); }
    public function createCheckbox(): Checkbox { return new MacCheckbox(); }
}

// Usage
function buildUI(GUIFactory $factory) {
    $button = $factory->createButton();
    $checkbox = $factory->createCheckbox();
    echo $button->render() . " & " . $checkbox->check();
}

buildUI(new MacFactory()); // Mac Button & Mac Checkbox

---

4. Builder Pattern

Separates the construction of a complex object from its representation.

✅ Use when creating complex objects step by step.

Example (PHP):

class Car {
    public string $engine;
    public string $color;
    public string $seats;
}

class CarBuilder {
    private Car $car;
    public function __construct() { $this->car = new Car(); }
    public function setEngine(string $engine): self { $this->car->engine = $engine; return $this; }
    public function setColor(string $color): self { $this->car->color = $color; return $this; }
    public function setSeats(string $seats): self { $this->car->seats = $seats; return $this; }
    public function build(): Car { return $this->car; }
}

// Usage
$car = (new CarBuilder())->setEngine("V8")->setColor("Red")->setSeats("4")->build();
print_r($car);

---

5. Prototype Pattern

Creates new objects by cloning an existing object (instead of creating from scratch).

✅ Use when creating an object is costly or complex.

Example (PHP):

class Document {
    public string $title;
    public string $content;

    public function __clone() {
        // Custom clone logic (if needed)
    }
}

// Usage
$doc1 = new Document();
$doc1->title = "Original";
$doc1->content = "Hello World";

$doc2 = clone $doc1;
$doc2->title = "Copy";

print_r($doc1);
print_r($doc2);

---

🔑 Summary of Creational Patterns:

1. Singleton → One instance only.

2. Factory Method → Create object via a method.

3. Abstract Factory → Create families of related objects.

4. Builder → Step-by-step complex object creation.

5. Prototype → Clone existing objects.