设计模式简要总结——创建型模式

1. AbstractFactory 抽象工程模式
    
      原理： 有多个具体工厂，分别可以创建自己的一套对象。再搞一个抽象的工厂，
             让这些具体工厂继承自它。 应用程序里面确定一个使用工厂的接口。
             在应用程序中根据场景需要（或不同产品）实例化一个具体的工厂，作为
             参数传给使用工厂创建对象的那个接口。
            
      实例： class Factory{
                 virtual Wall * MakeWall(); ////// 抽象工程定义的创建对象接口
                 virtual Room * MakeRoom();
                 virtual Door * MakeDoor();
             };
             class BoomFactory : Factory
             {
                 Wall * MakeWall();
                 Room * MakeRoom();
                 Door * MakeDoor();
             };
            
             应用程序：
             void createItem(Factory & factory){
                 factory.MakeWall();
                 factory.MakeRoom();
                 factory.MakeDoor();
             }
             {  ............
                BoomFactory factory;
                createItem(factory);///////////// 通过传入不同的factory，实现创建不同的、成套的对象。
             }
      应用：他把产品和创建过程完全分离了。 当需要提供一个独立的产品包，或强调一套对象的建立过程独立于本程序时，应用此方法。
      缺点：可被创建的Item集合被接口固定，被创建的对象类型不容易增加，如果增加一个，所有的类、子类都要修改。可以有个办法：
            把MakeXXX函数都去掉，替换为一个MakeItem（ITEMID id）。这样就可扩展item种类了。 但是感觉这个方式也不是很好。
  
  
    2. Builer
       原理： 同抽象工厂类似，也是先建立通用的创建对象的接口，然后不同的创建形式具体化到不同的builder类中。
      
       他与抽象工厂写法也类似。 不同的是builder强调复杂的对象是一步一步构造出来的。 抽象工厂着重多个不同的产品系列的对象。
      
    3. Factory Method 工厂方法
   
        原理：
       
        实现：有两种： 1是定义一个抽象工厂，由具体工厂实现里面各个产品的创建。
                       2是父类工厂有基础的创建实现，如果有对其中某些产品的创建有特殊要求，则由一个子类工厂继承父类并重载其创建实现。
                      
              同时，对产品的创建方法函数可以加入参，通过入参id创建不同的产品（这是以前最常用的一种方式，但是以前好像是滥用，什么都用这个方法）
             
              缺点： 为了仅修改其中的一个产品的创建，就要继承出一个工厂的子类。
             
        实例：class Factory{
                 Maze * createMaze(); ////// 注意这里同抽象工厂的区别，抽象工厂是没有这个接口的，因为抽象工厂是在app的create函数中调用工厂中各个产品的创建方法。
                                             这样看，工厂方法对于增加产品类型时不用APP做修改，但是这点也算不上优点，因为APP修改的那一点点也不算什么。
                                             他们的共同问题是工厂类的子类会多，不同的产品类型会催生出工厂子类。
                 virtual Wall * MakeWall();
                 virtual Room * MakeRoom();
                 virtual Door * MakeDoor();
                 createMaze()
                 {
                     MakeWall();
                     MakeRoom();
                     MakeDoor();
                 }
             };
             class BoomFactory : Factory
             {
                 Wall * MakeWall();
                 Room * MakeRoom();
                 Door * MakeDoor()
                 {
                      //// 可以通过重载此函数，实现生成不同的产品对象。
                      return new BoomDoor;
                 }
             };
               
  
    4. prototype 原型
   
        原理： 思路同抽象工厂类似。不同的是原型不需要继承出多个子类。抽象工厂也好、builder也好。。都是根据不同的构造器构造出一组
               不同的产品。而每个产品一定是有自己的实现类的。 原型的思路就是在工厂中存储不同产品的原型，在创建函数中按照这些原型
               创建产品。
              
        实现：class Factory｛
                  Factory(Room * r, Door * d):_protoRoom(r),_protoDoor(r){}
                  virtual Room * MakeRoom()
                  {
                      return _protoRoom->clone();
                  }
                  virtual Door * MakeDoor()
                  {
                      return _protoDoor->clone();
                  }
              private:
                  Room * _protoRoom;
                  Door * _protoDoor;
              ｝；
              Room * clone()
              {
                  return new Room(*this);
              }
           他的好处是不用创建多个子类。 但是需要维护原型列表。 总的来说这个思路挺好的，但是当产品中包含其他的引用的时候，clone方法将难以实现。  
          
     5. singleton 单件