php设计模式 -- 工厂模式

工厂模式的最大优点在于创建对象上面，就是把创建对象的过程封装起来，这样随时可以产生一个新的对象。
减少代码进行复制粘帖，耦合关系重，牵一发动其他部分代码。

通俗的说，以前创建一个对象要使用new，现在把这个过程封装起来了。
假设不使用工厂模式：那么很多地方调用类a，代码就会这样子创建一个实例：new a(),假设某天需要把a类的名称修改，意味着很多调用的代码都要修改。

工厂模式的优点就在创建对象上。
工厂模式的优点就在创建对象上。建立一个工厂（一个函数或一个类方法）来制造新的对象,它的任务就是把对象的创建过程都封装起来，
创建对象不是使用new的形式了。而是定义一个方法，用于创建对象实例。

<?php
namespace Libs;

class Factory
{
    public static function createDatabase()
    {
        $db = new Database();
        return $db;
    } 
}

调用时,不是使用 $db = new  LibsDatabase();

而是 $db =  LibsFactory::createDatabase();

*简单工厂模式

<?php 
/**
 * 简单工厂模式又叫静态工厂方法模式，理解为可以通过一个静态方法创建对象
 * */
 
interface animal{
    function eat();
}
class herbivore implements animal{
    function eat(){
        echo "吃草<br>";
    }
}
class carnivore implements animal{
    function eat(){
        echo "吃肉<br>";
    }
}
class omnivores implements animal{
    function eat(){
        echo "杂食<br>";
    }
}
 
class Demo{
    static function createHerbivore(){
        return new herbivore;
    }
    static function createCarnivore(){
        return new carnivore;
    }
    static function createOmnivores(){
        return new omnivores;
    }
}
$herbivore = Demo::createHerbivore();
$herbivore->eat();
$carnivore = Demo::createCarnivore();
$carnivore->eat();
$omnivores = Demo::createOmnivores();
$omnivores->eat();

*工厂方法模式

<?php 
/**
 * 工厂模式 定义一个创建对象的接口，让子类决定哪个类实例化，解决简单工厂模式中封闭开发原则
 * */
 
interface animal{
    function eat();
}
class herbivore implements animal{
    function eat(){
        echo "吃草<br>";
    }
}
class carnivore implements animal{
    function eat(){
        echo "吃肉<br>";
    }
}
class omnivores implements animal{
    function eat(){
        echo "杂食<br>";
    }
}
//将对象的创建抽象成一个接口
interface createAnimal{
    function create();
}
class FactoryHerbivore implements createAnimal{
    function create(){
        return new herbivore;
    }
}
class FactoryCarnivore implements createAnimal{
    function create(){
        return new carnivore;
    }
}
class FactoryOmnivores implements createAnimal{
    function create(){
        return new omnivores;
    }
}
class Demo{
    function test(){
        $Factory = new FactoryHerbivore();
        $herbivore = $Factory->create();
        $herbivore->eat();
        
        $Factory = new FactoryCarnivore();
        $carnivore = $Factory->create();
        $carnivore->eat();
        
        $Factory = new FactoryOmnivores();
        $omnivores = $Factory->create();
        $omnivores->eat();
    }
}
 
$demo = new Demo();
$demo->test();

*抽象工厂方法

<?php 
/**
 * 抽象工厂  提供一个创建一系列相关或相互依赖对象的接口
 * 与工厂方法的区别，这里定义了一系列接口，工厂方法只有一个
 * 
 * */
 
interface animal{
    function eat();
}
class yesHerbivore implements animal{
    function eat(){
        echo "吃草<br>";
    }
}
class noHerbivore implements animal{
    function eat(){
        echo "不吃草<br>";
    }
}
class yesCarnivore implements animal{
    function eat(){
        echo "吃肉<br>";
    }
}
class noCarnivore implements animal{
    function eat(){
        echo "不吃肉<br>";
    }
}
class yesOmnivores implements animal{
    function eat(){
        echo "杂食<br>";
    }
}
class noOmnivores implements animal{
    function eat(){
        echo "不杂食<br>";
    }
}
//本质区别在这里，将对象的创建抽象成一个接口
interface createAnimal{
    function createYes();
    function createNo();
}
class FactoryHerbivore implements createAnimal{
    function createYes(){
        return new yesHerbivore();
    }
    function createNo(){
        return new noHerbivore();
    }
}
class FactoryCarnivore implements createAnimal{
    function createYes(){
        return new yesCarnivore();
    }
    function createNo(){
        return new noCarnivore();
    }
}
class FactoryOmnivores implements createAnimal{
    function createYes(){
        return new yesOmnivores();
    }
    function createNo(){
        return new noOmnivores();
    }
}
class Demo{
    function test(){
        $Factory = new FactoryHerbivore();
        $herbivore = $Factory->createYes();
        $herbivore->eat();
        
        $herbivore = $Factory->createNo();
        $herbivore->eat();
        
        $Factory = new FactoryCarnivore();
        $carnivore = $Factory->createYes();
        $carnivore->eat();
        
        $carnivore = $Factory->createNo();
        $carnivore->eat();
        
        $Factory = new FactoryOmnivores();
        $omnivores = $Factory->createYes();
        $omnivores->eat();
        
        $omnivores = $Factory->createNo();
        $omnivores->eat();
    }
}
 
$demo = new Demo();
$demo->test();

简单工厂模式：工厂类负责创建的对象较少，客户只知道传入工厂类的参数，对于如何创建对象不关心。

工厂方法模式：当一个类不知道它所必须创建对象的类或一个类希望由子类来指定它所创建的对象时，当类将创建对象的职责委托给多个帮助子类中得某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候，可以使用工厂方法模式。

抽象工厂模式：一个系统不应当依赖于产品类实例何如被创建，组合和表达的细节，这对于所有形态的工厂模式都是重要的。这个系统有多于一个的产品族，而系统只消费其 中某一产品族。同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。系统提供一个产品类的库，所有的产品以同样的接口出现，从 而使客户端不依赖于实现。