简单工厂

<?php
/**
 * Created by PhpStorm.
 * User: xingdong
 * Date: 2019/8/3
 * Time: 上午10:05
 */

//简单工厂
interface Product
{
    public function getPrice();
    public function getName();
}

class ProductA implements Product
{
    public function getPrice()
    {
        return 100;
    }

    public function getName()
    {
        return 'ProductA';
    }
}

class ProductB implements Product
{
    public function getPrice()
    {
        return 200;
    }

    public function getName()
    {
        return 'ProductB';
    }
}

class ProductC implements Product
{
    public function getPrice()
    {
        return 300;
    }

    public function getName()
    {
        return 'ProductC';
    }
}

class Factory
{
    public static function createProduct($type)
    {
        $product = null;
        switch ($type){
            case "A":
                $product = new ProductA();
                break;
            case "B":
                $product = new ProductB();
                break;
            case "C":
                $product = new ProductC();
                break;
        }
        return $product;
    }
}

$productA = Factory::createProduct('A');
$productB = Factory::createProduct('B');
$productC = Factory::createProduct('C');

/**
 * 以上便是简单工厂模式的一个典型事例，当用户需要新增产品ProductD时，必须在工厂类的生产方法中增加
对应的判断分支，所以简单工厂模式违背了开放封闭原则。
简单工厂模式，利用静态方法根据输入参数生成对应的产品，隐藏了产品实例化的细节。
总结： 简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，
对于客户端来说，去除了与具体产品的依赖。但是当需求变动的时候，需要对原有的类进行修改，违背了开放封闭原则。
 *
 *
 */

工厂模式

<?php
/**
 * Created by PhpStorm.
 * User: xingdong
 * Date: 2019/8/3
 * Time: 上午10:05
 */

//工厂方式模式
interface Product
{
    public function getPrice();
    public function getName();
}

class ProductA implements Product
{
    public function getPrice()
    {
        return 100;
    }

    public function getName()
    {
        return 'ProductA';
    }
}

class ProductB implements Product
{
    public function getPrice()
    {
        return 200;
    }

    public function getName()
    {
        return 'ProductB';
    }
}

class ProductC implements Product
{
    public function getPrice()
    {
        return 300;
    }

    public function getName()
    {
        return 'ProductC';
    }
}

interface IFactory{
    public function createProduct();
}

class FactoryA implements IFactory
{
    public function createProduct()
    {
        return new ProductA();
    }
}
class FactoryB implements IFactory
{
    public function createProduct()
    {
        return new ProductB();
    }
}
class FactoryC implements IFactory
{
    public function createProduct()
    {
        return new ProductC();
    }
}

$factoryA = new FactoryA();
$factoryA-&gt;createProduct();

$factoryB = new FactoryB();
$factoryB-&gt;createProduct();

$factoryC = new FactoryC();
$factoryC-&gt;createProduct();

/**
 * 当需要增加一个新产品ProductD,只需要新建对应的FactoryD来实现生产功能即可,对原有的代码
没有任何影响，非常符合开放封闭原则，但是由于每增加一个产品，都需要新增对应的生产工厂，导致增加额外的开发工作量。

总结：由于使用了多态，工厂方法克服了简单工厂违背的开放封闭原则的缺点，又保持了封装对象创建过程的优点。
 */

抽象工厂

<?php
/**
 * Created by PhpStorm.
 * User: xingdong
 * Date: 2019/8/3
 * Time: 上午10:05
 */

//抽象工厂方式
//商品
interface Product
{
    public function getPrice();
    public function getName();
}

class ProductA implements Product
{
    public function getPrice()
    {
        return 100;
    }

    public function getName()
    {
        return 'ProductA';
    }
}

class ProductB implements Product
{
    public function getPrice()
    {
        return 200;
    }

    public function getName()
    {
        return 'ProductB';
    }
}

class ProductC implements Product
{
    public function getPrice()
    {
        return 300;
    }

    public function getName()
    {
        return 'ProductC';
    }
}

//礼品
interface Gift
{
    public function getGiftName();
}

class GiftA implements Gift
{
    public function getGiftName()
    {
        return 'GiftA';
    }
}

class GiftB implements Gift
{
    public function getGiftName()
    {
        return 'GiftB';
    }
}

class GiftC implements Gift
{
    public function getGiftName()
    {
        return 'GiftC';
    }
}

interface IFactory{
    public function createProduct();
    public function createGift();
}

class FactoryA implements IFactory
{
    public function createProduct()
    {
        return new ProductA();
    }

    public function createGift()
    {
        return new GiftA();
    }
}
class FactoryB implements IFactory
{
    public function createProduct()
    {
        return new ProductB();
    }
    public function createGift()
    {
        return new GiftB();
    }
}
class FactoryC implements IFactory
{
    public function createProduct()
    {
        return new ProductC();
    }
    public function createGift()
    {
        return new GiftC();
    }
}

$factoryA = new FactoryA();
$factoryA-&gt;createProduct();

$factoryB = new FactoryB();
$factoryB-&gt;createProduct();

$factoryC = new FactoryC();
$factoryC-&gt;createProduct();

/**
 * 总结：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需制定他们具体的类。
抽象工厂接口，应该包含所有的产品创建的抽象方法，我们可以定义实现不止一个接口，
一个工厂也可以生产不止一种产品类，和工厂方法模式一样，抽象工厂模式同样实现了开发封闭原则
 */