创建型模式---工厂模式

1.简单工厂模式

（1）接口中定义一些方法，实现接口的类实现接口中的方法
（2）工厂类中实例对象

Product.php:

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 19:29
 */
namespace IMooc;
interface Product{
    function buy();
}

Huawei.php:

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 19:29
 */
namespace IMooc;

class Huawei implements Product{
    function buy()
    {
        echo "HUAWEI phone buy successful\n";
    }
}

Iphone.php

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 16:14
 */
namespace IMooc;

class Iphone implements Product{

    public function buy()
    {
        echo "Iphone buy successful\n";
    }
}

SimpleProduct:

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 16:07
 */

namespace IMooc;

use IMooc\Iphone;

class SimpleFactory
{
    static function buyIphone($type)
    {
        switch ($type){
            case 'Iphone':
                return new Iphone();
                break;
            case 'Huawei':
                return new Huawei();
                break;
        }
    }
}

Index.php

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/25
 * Time: 20:01
 */

//定义文件目录
define('BASEDIR', __DIR__);
include BASEDIR.'/IMooc/Loader.php';
spl_autoload_register('\\IMooc\\Loader::autoload');


$phone1=\IMooc\SimpleFactory::buyIphone('Iphone');
$phone1->buy();

$phone2=\IMooc\SimpleFactory::buyIphone('Huawei');
$phone2->buy();

执行结果：

优点

• 客户端中可以免除直接创建产品对象，有工厂类创建
• 客户端无须知道产品的类名，只需要传递产品类所需要的参数
• 解耦，可以不修改客户端代码的情况下更换和增加新的具体产品类

缺点

• 增加系统中类的个数，一个产品一个类
• 使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构
• 不易扩展，添加新产品需要修改工厂类的逻辑

2.工厂方法模式（多态工厂模式）

工厂模式一个工厂可以生产很多产品，工厂方法模式是一个工厂生产一种产品

工厂类不再负责所有对象的创建而是将创建的工作交给子类去做，成为一个抽象工厂角色，仅仅给出具体工厂类必须实现的接口，而不接触哪一个产品类应该被实例化

Factory.php

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 16:07
 */

namespace IMooc;
interface Factory
{
    static function buyPhone();
}

HuaweiFactory.php

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 20:42
 */
namespace IMooc;
class HuaweiFactory implements Factory{
    static function buyPhone()
    {
        return new Huawei();
    }
}

IphoneFactory.php

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 20:40
 */
namespace IMooc;
class IphoneFactory implements Factory{

    static function buyPhone()
    {
        return new Iphone();
    }
}

$phone1=IMooc\IphoneFactory::buyPhone();
$phone1->buy();

$phone2=\IMooc\HuaweiFactory::buyPhone();
$phone2->buy();

运行结果：

优点：

• 更加符合开闭原则
• 使得工厂可以自主确定创建何种产品对象
  缺点：
• 添加产品需要编写具体产品类还要提供相应的具体工厂类，带来更大的开销和复杂度

3.抽象工厂模式

主要角色
抽象工厂(Abstract Factory)：它声明一个创建抽象产品对象的接口。通常以接口或抽象类实现，所有的具体工厂类必须实现这个接口或继承这个类。
具体工厂(Concrete Factory)：实现创建产品对象的操作。客户端直接调用这个角色创建产品的实例。这个角色包含有选择合适的产品对象的逻辑。通常使用具体类实现。
抽象产品(Abstract Product)：声明一类产品的接口。它是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。
具体产品(Concrete Product)：实现抽象产品角色所定义的接口，定义一个将被相应的具体工厂创建的产品对象。其内部包含了应用程序的业务逻辑。

抽象工厂

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 16:07
 */
namespace IMooc;
interface AbstractFactory
{
    public function buyHuawei();
    public function buyIphone();
}

具体工厂

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/27
 * Time: 10:39
 */
namespace IMooc;
class Factory64 implements AbstractFactory{
    function buyHuawei()
    {
        return new Huawei64();
    }
    function buyIphone()
    {
        return new Iphone64();
    }
}

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/27
 * Time: 10:40
 */
namespace IMooc;
class Factory128 implements AbstractFactory{
    public function buyHuawei()
    {
        return new Huawei128();
    }
    public function buyIphone()
    {
        return new Iphone128();
    }
}

抽象产品

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 19:29
 */
namespace IMooc;
//抽象产品
interface Huawei{

    function Buy();
}

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/26
 * Time: 16:14
 */
namespace IMooc;

interface Iphone{

    function Buy();
}

具体产品

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/27
 * Time: 10:43
 */
namespace IMooc;
class Huawei64 implements Huawei{
    function Buy()
    {
        echo "you have bought 64g Huawei\n";
    }
}

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/27
 * Time: 10:43
 */
namespace IMooc;
class Huawei128 implements Huawei{
    function Buy()
    {
        echo "you have bought 128g Huawei\n";
    }
}

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/27
 * Time: 10:45
 */
namespace IMooc;
class Iphone64 implements Iphone{
    function Buy()
    {
        echo "you have bought 64g iphone\n";
    }
}

<?php
/**
 * Created by PhpStorm.
 * User: 何晓宏
 * Date: 2018/9/27
 * Time: 10:45
 */
namespace IMooc;
class Iphone128 implements Iphone{
    function Buy()
    {
        echo "you have bought 128g iphone\n";
    }
}

运行结果

优点

• 一个工厂可以生产多个商品，符合开闭原则
• 实现了高内聚低耦合的设计目的
  缺点
• 开闭原则的倾斜性，虽然增加新的工厂和产品容易，担增加新的产品等级结构麻烦
• 难以拓展抽象工厂来生产新种类的产品，抽象工厂角色中规定了所有可能被创建的产品集合