设计模式之工厂模式

工厂模式
工厂模式具体可分为三类模式：简单工厂模式，工厂方法模式，抽象工厂模式；

1.简单工厂模式

又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

  ";
      }
  }
  class Dog
  {
      function __construct()
      {
          echo "I am Dog class 
";
      }
  }
  // 工厂类
  class Factory
  {
      public static function CreateAnimal($name){
          if ($name == 'cat') {
              return new Cat();
          } elseif ($name == 'dog') {
              return new Dog();
          }
         switch ($name) {
         	case 'cat':
         		return new Cat();
         		break;
         	case 'dog' :
         		return new Dog();
         		break;
         	default:
         		# code...
         		break;
         }
      }
  }

  $cat = Factory::CreateAnimal('cat');
  $dog = Factory::CreateAnimal('dog');

优点:：实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，
缺点：在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。

2、工厂方法
这个模式是一个 “真正” 的设计模式，因为它遵循了依赖反转原则（Dependency Inversion Principle） 众所周知这个 “D” 代表了真正的面向对象程序设计。

它意味着工厂方法类依赖于类的抽象，而不是具体将被创建的类，这是工厂方法模式与简单工厂模式的重要区别。

  ";
      }
      public function say(){
          echo "I am Cat class 
";
      }
  }
  class Dog implements Animal
  {
      public function run(){
          echo "I'm running fast 
";
      }
      public function say(){
          echo "I am Dog class 
";
      }
  }
  abstract class Factory{
      abstract static function createAnimal();
  }
  class CatFactory extends Factory
  {
      public static function createAnimal()
      {
          return new Cat();
      }
  }
  class DogFactory extends Factory
  {
      public static function createAnimal()
      {
          return new Dog();
      }
  }

  $cat = CatFactory::createAnimal();
  $cat->say();
  $cat->run();

  $dog = DogFactory::createAnimal();
  $dog->say();
  $dog->run();

3.抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

此模式是对工厂方法模式的进一步扩展。在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。

";
  }

  public function watch()
  {
      echo "I'm watching TV 
";
  }
}

interface PC{
  public function work();
  public function play();
}

class LenovoPc implements PC
{
  public function work()
  {
      echo "I'm working on a Lenovo computer 
";
  }
  public function play()
  {
      echo "Lenovo computers can be used to play games 
";
  }
}

abstract class Factory{
  abstract public static function createPc();
  abstract public static function createTv();
}

class ProductFactory extends Factory
{
  public static function createTV()
  {
      return new HaierTv();
  }
  public static function createPc()
  {
      return new LenovoPc();
  }
}

$newTv = ProductFactory::createTV();
$newTv->open();
$newTv->watch();

$newPc = ProductFactory::createPc();
$newPc->work();
$newPc->play();

进一步举例
下面例子中鼠标，键盘，耳麦为产品，惠普，戴尔为工厂。

简单工厂模式
简单工厂模式不是 23 种里的一种，简而言之，就是有一个专门生产某个产品的类。

比如下图中的鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标。

工厂模式
工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。

戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。

生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。

后续直接调用鼠标工厂.生产鼠标()即可

抽象工厂模式
抽象工厂模式也就是不仅生产鼠标，同时生产键盘。

也就是 PC 厂商是个父类，有生产鼠标，生产键盘两个接口。

戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。

创建工厂时，由戴尔工厂创建。

后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

在抽象工厂模式中，假设我们需要增加一个工厂

假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承 PC 厂商。

之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类即可。

在抽象工厂模式中，假设我们需要增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。

之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。 以上。