设计模式是软件开发中经过验证的、用于解决常见问题的最佳实践。在 PHP 中，工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式是常见的创建型设计模式，它们主要关注对象的创建过程，帮助开发者更高效地管理复杂性。

---

1. 工厂方法模式（Factory Method Pattern）

1.1 定义

• 工厂方法模式是一种创建型设计模式，它通过定义一个用于创建对象的接口，但由子类决定实例化哪一个类。
• 核心思想：将对象的创建延迟到子类。

1.2 特点

• 解耦了对象的创建与使用。
• 支持开闭原则（对扩展开放，对修改关闭）。

1.3 实现方法

<?php
// 抽象产品接口
interface Product {
    public function operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    public function operation() {
        echo "ConcreteProductA Operation\n";
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public function operation() {
        echo "ConcreteProductB Operation\n";
    }
}

// 抽象工厂
abstract class Creator {
    abstract public function factoryMethod(): Product;

    public function someOperation() {
        $product = $this->factoryMethod();
        echo "Creator: The same creator's code has just worked with ";
        $product->operation();
    }
}

// 具体工厂A
class ConcreteCreatorA extends Creator {
    public function factoryMethod(): Product {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteCreatorB extends Creator {
    public function factoryMethod(): Product {
        return new ConcreteProductB();
    }
}

// 使用示例
$creatorA = new ConcreteCreatorA();
$creatorA->someOperation(); // 输出: Creator: The same creator's code has just worked with ConcreteProductA Operation

$creatorB = new ConcreteCreatorB();
$creatorB->someOperation(); // 输出: Creator: The same creator's code has just worked with ConcreteProductB Operation

1.4 适用场景

• 当需要根据不同的条件创建不同类型的对象时。
• 需要将对象的创建逻辑与使用逻辑分离。

---

2. 抽象工厂模式（Abstract Factory Pattern）

2.1 定义

• 抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。

2.2 特点

• 提供了一组相关的对象，而不是单一对象。
• 适用于需要创建一系列具有关联性的对象。

2.3 实现方法

<?php
// 抽象产品接口
interface Button {
    public function paint();
}

interface Checkbox {
    public function paint();
}

// 具体产品
class WindowsButton implements Button {
    public function paint() {
        echo "Rendering a button in Windows style.\n";
    }
}

class WindowsCheckbox implements Checkbox {
    public function paint() {
        echo "Rendering a checkbox in Windows style.\n";
    }
}

class MacOSButton implements Button {
    public function paint() {
        echo "Rendering a button in MacOS style.\n";
    }
}

class MacOSCheckbox implements Checkbox {
    public function paint() {
        echo "Rendering a checkbox in MacOS style.\n";
    }
}

// 抽象工厂接口
interface GUIFactory {
    public function createButton(): Button;
    public function createCheckbox(): Checkbox;
}

// 具体工厂
class WindowsFactory implements GUIFactory {
    public function createButton(): Button {
        return new WindowsButton();
    }

    public function createCheckbox(): Checkbox {
        return new WindowsCheckbox();
    }
}

class MacOSFactory implements GUIFactory {
    public function createButton(): Button {
        return new MacOSButton();
    }

    public function createCheckbox(): Checkbox {
        return new MacOSCheckbox();
    }
}

// 使用示例
function clientCode(GUIFactory $factory) {
    $button = $factory->createButton();
    $checkbox = $factory->createCheckbox();

    $button->paint();
    $checkbox->paint();
}

echo "Testing on Windows:\n";
clientCode(new WindowsFactory());

echo "\nTesting on MacOS:\n";
clientCode(new MacOSFactory());

2.4 适用场景

• 需要创建一组相关或相互依赖的对象。
• 系统需要支持多种主题或风格。

---

3. 单例模式（Singleton Pattern）

3.1 定义

• 单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。

3.2 特点

• 构造函数私有化，防止外部实例化。
• 提供静态方法获取唯一实例。

3.3 实现方法

<?php
class Singleton {
    private static $instance;

    // 私有化构造函数，防止外部实例化
    private function __construct() {}

    // 获取唯一实例
    public static function getInstance(): Singleton {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    // 示例方法
    public function showMessage() {
        echo "Hello from the Singleton!\n";
    }
}

// 使用示例
$instance1 = Singleton::getInstance();
$instance1->showMessage(); // 输出: Hello from the Singleton!

$instance2 = Singleton::getInstance();
var_dump($instance1 === $instance2); // 输出: bool(true)

3.4 适用场景

• 需要全局唯一实例的场景，如数据库连接池、日志记录器等。

---

4. 建造者模式（Builder Pattern）

4.1 定义

• 建造者模式是一种创建型设计模式，用于构建复杂对象，允许分步骤创建对象并隐藏其内部细节。

4.2 特点

• 将复杂对象的构建过程与其表示分离。
• 支持灵活的对象构建。

4.3 实现方法

<?php
// 产品类
class Product {
    private $parts = [];

    public function addPart($part) {
        $this->parts[] = $part;
    }

    public function showParts() {
        echo "Product parts: " . implode(", ", $this->parts) . "\n";
    }
}

// 抽象建造者
interface Builder {
    public function buildPartA();
    public function buildPartB();
    public function getResult(): Product;
}

// 具体建造者
class ConcreteBuilder implements Builder {
    private $product;

    public function __construct() {
        $this->reset();
    }

    public function reset() {
        $this->product = new Product();
    }

    public function buildPartA() {
        $this->product->addPart("PartA");
    }

    public function buildPartB() {
        $this->product->addPart("PartB");
    }

    public function getResult(): Product {
        $result = $this->product;
        $this->reset();
        return $result;
    }
}

// 指挥者
class Director {
    private $builder;

    public function setBuilder(Builder $builder) {
        $this->builder = $builder;
    }

    public function buildMinimalViableProduct() {
        $this->builder->buildPartA();
    }

    public function buildFullFeaturedProduct() {
        $this->builder->buildPartA();
        $this->builder->buildPartB();
    }
}

// 使用示例
$builder = new ConcreteBuilder();
$director = new Director();

$director->setBuilder($builder);
$director->buildMinimalViableProduct();

$product1 = $builder->getResult();
$product1->showParts(); // 输出: Product parts: PartA

$director->buildFullFeaturedProduct();
$product2 = $builder->getResult();
$product2->showParts(); // 输出: Product parts: PartA, PartB

4.4 适用场景

• 需要分步骤构建复杂对象。
• 对象的构建过程需要灵活性。

---

5. 原型模式（Prototype Pattern）

5.1 定义

• 原型模式是一种创建型设计模式，通过克隆现有对象来创建新对象，避免重复初始化。

5.2 特点

• 利用 PHP 的 clone 关键字实现对象复制。
• 支持深拷贝和浅拷贝。

5.3 实现方法

<?php
class Prototype {
    public $property;

    public function __construct($property) {
        $this->property = $property;
    }

    public function cloneObject() {
        return clone $this;
    }
}

// 使用示例
$original = new Prototype("Original Value");
echo "Original Property: " . $original->property . "\n"; // 输出: Original Property: Original Value

$clone = $original->cloneObject();
$clone->property = "Cloned Value";

echo "Original Property After Clone: " . $original->property . "\n"; // 输出: Original Property After Clone: Original Value
echo "Cloned Property: " . $clone->property . "\n"; // 输出: Cloned Property: Cloned Value

5.4 适用场景

• 需要频繁创建相似对象。
• 对象的初始化成本较高。

---

6. 总结

模式	核心思想	适用场景
工厂方法模式	子类决定实例化哪个类	需要根据不同条件创建不同对象
抽象工厂模式	创建一组相关或依赖的对象	需要创建多个相关对象
单例模式	确保一个类只有一个实例	需要全局唯一实例
建造者模式	分步骤构建复杂对象	对象构建过程复杂且需要灵活性
原型模式	通过克隆现有对象创建新对象	需要频繁创建相似对象

这些模式各有优缺点，选择合适的模式可以显著提升代码的可维护性和扩展性。