一、简单工厂模式

简单工厂模式又称为静态工厂方法模式，属于类的创建模式。通过传不同的参数实现不同类的实例化并返回实例化后的对象。

优点：对类进行统一实例化，当类名或类的参数变动时不用去全局查找并修改，只需工厂一处修改即可；如果使用到Interface，定义了一个公共类（Common）的话，所有实现的子类都有公共类中需要实现的方法（name）；对类的调用方便，直接向工厂调用即可。

缺点：当需要创建的类越多越多时工厂类中的判断逻辑越来越多；新增类时需要修改代码添加逻辑，否则无法扩展。

<?php
 
interface Common
{
    // 定义一个接口， 让子类实现
    public function name();
}
 
class Class1 implements Common
{
    public function name(): string
    {
        return 'Class1' . '<br/>';
    }
}
 
class Class2 implements Common
{
    public function name(): string
    {
        return 'Class2' . '<br/>';
    }
}

// 工厂类
class simpleFactory
{
    public static function createObject(string $className): object
    {
        if (!empty($className) && class_exists($className)) {
            if ($className == 'Class1') {
                return new $className();
            } elseif ($className == 'Class2') {
                return new $className();
            }
        }
        return new \stdClass();
    }
}

// 调用工厂类中静态方法实现类的实例化
echo simpleFactory::createObject('Class1')->name();
echo simpleFactory::createObject('Class2')->name();

输出结果：

Class1
Class2

二、工厂方法模式

工厂方法模式是在简单工厂模式上的扩展，并加入了抽象。当增加类时，只需要增加一个工厂类的文件，在文件中实现抽象工厂中的方法，并实例化返回这个类独有的工厂类对象。这样使统的扩展性变得很好，符合面向对象编程的开闭原则。工厂方法模式把原来简单工厂模式中的createObject细节分开放到子类中去实现。

<?php
 
interface Common
{
    // 定义一个接口， 让子类实现
    public function name();
}
 
class Class1 implements Common
{
    public function name(): string
    {
        return 'Class1' . '<br/>';
    }
}
 
class Class2 implements Common
{
    public function name(): string
    {
        return 'Class2' . '<br/>';
    }
}

// 工厂方法类
abstract class methodFactory
{
    protected abstract static function createObject();
}

// 实现Class1工厂
class Class1Factory extends methodFactory{
    public static function createObject(): object
    {
        return new Class1();
    }
}

// 实现Class2工厂
class Class2Factory extends methodFactory{
    public static function createObject(): object
    {
        return new Class2();
    }
}

// 调用工厂方法
echo Class1Factory::createObject()->name();
echo Class2Factory::createObject()->name();

输出结果：

Class1
Class2

三、抽象工厂模式

抽象工厂模式是在工厂方法模式上的扩充，支持多个工厂的抽象方法的实现。将多个类统一到一个工厂中实现。当再增加一个抽象工厂（abstractFactory）中要实现的方法时，需要修改（abstractFactory）类和实现工厂类的子类代码。增加了工厂类的抽象性和理解难度。

<?php
 
interface Class1
{
    // 定义一个接口， 让子类实现
    public function name();
}
 
class ClassA implements Class1
{
    public function name(): string
    {
        return 'ClassA name' . '<br/>';
    }
}
 
class ClassB implements Class1
{
    public function name(): string
    {
        return 'ClassB name' . '<br/>';
    }
}
 
 
interface Class2
{
    // 定义一个接口， 让子类实现
    public function type();
}
 
class ClassC implements Class2
{
    public function type(): string
    {
        return 'ClassC type' . '<br/>';
    }
}
 
class ClassD implements Class2
{
    public function type(): string
    {
        return 'ClassD type' . '<br/>';
    }
}

// 工厂方法类
abstract class abstractFactory
{
    protected abstract static function createObjectName();
    protected abstract static function createObjectType();
}

class Obj1Factory extends abstractFactory{
    public static function createObjectName(): object
    {
        return new ClassA();
    }
 
    public static function createObjectType(): object
    {
        return new ClassC();
    }
}

class Obj2Factory extends abstractFactory{
    public static function createObjectName(): object
    {
        return new ClassB();
    }
 
    public static function createObjectType(): object
    {
        return new ClassD();
    }
}

echo Obj1Factory::createObjectName()->name();
echo Obj1Factory::createObjectType()->type();
 
echo Obj2Factory::createObjectName()->name();
echo Obj2Factory::createObjectType()->type();

ClassA name
ClassC type
ClassB name
ClassD type