工厂模式

（一）、简单的工厂模式

class A {
    private $mode = 1;
    function __construct( $mode)
    {
        $this->mode = $mode;
    }
    
    function getSomething()
    {
        switch ($this->mode) {
            case 1:
                //B,C,D 代表不同的处理类
                return new B();
            case 2:

        		return new C(); 
        	default: 
        		return new D(); 
    	} 
    }
}

缺陷：通常情况下，创建对象需要制定条件，单条件语句重复蔓延，感觉不应该乐观

（二）、工厂方法模式

工厂方法模式：将创建者类与要生产的产品类分离开来。创建者类是一个工厂类，其中定义与生成产品对象的类方法。如果没有提供默认实现，那么就由创建者类的子类来执行实例化。一般情况下，就是创建者类的每个子类实例化一个相应产品子类。

class E extends A{
    public function getB(){
        return new B();
    }
    public function getC(){
        return new C();
    }
    public function getD(){
        return new D();
    }
}

abstract class A {
    abstract function getB();
    abstract function getC();
    abstract function getD(); 
}

缺陷：可能会导致不必要的子类化

（三）、抽象工厂模式

大型应用中，可能需要工厂来产生一组相关的类。抽象工厂模式可解决这个问题

abstract class A
{
    abstract public function use();
}

class A1 extends A
{
    public function use(){
        var_dump('A1');
    }
}
class A2 extends A
{
    public function use(){
        var_dump('A2');
    }
}

//AbstractProduct：抽象产品
abstract class B
{
    abstract public function eat();
}

//Product：具体产品
class B1 extends B
{
    public function eat()
    {
        var_dump('B1');
    }
}
class B2 extends B
{
    public function eat()
    {
        var_dump('B2');
    }
}

abstract class AbstractFactory
{
    abstract public function createA();
    abstract public function createB();
}

class ConcreteFactory1 extends AbstractFactory
{
    public function createA()
    {
        return new A1();
    }
    public function createB()
    {
        return new B1();
    }
}
class ConcreteFactory2 extends AbstractFactory
{
    public function createA()
    {
        return new A2();
    }
    public function createB()
    {
        return new B2();
    }
}

$a=new ConcreteFactory1();
$b=$a->createA();
$b->use();

$c=new ConcreteFactory2();
$d=$c->createB();
$d->eat();

输出

string 'productA1' (length=2)
string 'productB2' (length=2)

好处：系统与实现细节分离出来

简单工厂：适用于生成数量少，功能简单的产品

工厂模式：适用于生成数量多，功能复杂的产品，相比简单工厂来说：业务更复杂，功能更多，但是产品族还是单个。

抽象工厂：适用于生成多个产品族、多个产品树的情景(产品族，产品树)。相比于工厂模式，更容易扩展添加新的产品族。