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

124 阅读 0 评论 82 点赞

我是靠谱客的博主超帅蛋挞，最近开发中收集的这篇文章主要介绍设计模式简要总结——创建型模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

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 单件