9、设计模式 - 技术栈

设计模式

1、工厂模式

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。工厂模式作为一种创建模式，一般在创建复杂对象时，考虑使用；在创建简单对象时，建议直接new完成一个实例对象的创建。

1.1、简单工厂模式

主要特点是需要在工厂类中做判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。使用简单工厂模式，我们只需要知道具体的产品型号就可以创建一个产品。

缺点：工厂类集中了所有产品类的创建逻辑，如果产品量较大，会使得工厂类变的非常臃肿。

1.2、工厂方法模式

定义一个创建对象的接口，其子类去具体现实这个接口以完成具体的创建工作。如果需要增加新的产品类，只需要扩展一个相应的工厂类即可。

缺点：产品类数据较多时，需要实现大量的工厂类，这无疑增加了代码量。

复制代码

  1 /*
  2 关键代码：创建过程在其子类执行。
  3 */
  4 
  5 #include <iostream>
  6 
  7 using namespace std;
  8 
  9 //产品抽象类
 10 class Tank
 11 {
 12 public:
 13     virtual const string& type() = 0;
 14 };
 15 
 16 //具体的产品类
 17 class Tank56 : public Tank
 18 {
 19 public:
 20     Tank56():Tank(),m_strType("Tank56")
 21     {
 22     }
 23 
 24     const string& type() override
 25     {
 26         cout << m_strType.data() << endl;
 27         return m_strType;
 28     }
 29 private:
 30     string m_strType;
 31 };
 32 
 33 //具体的产品类
 34 class Tank96 : public Tank
 35 {
 36 public:
 37     Tank96():Tank(),m_strType("Tank96")
 38     {
 39     }
 40     const string& type() override
 41     {
 42         cout << m_strType.data() << endl;
 43         return m_strType;
 44     }
 45 
 46 private:
 47     string m_strType;
 48 }; 
 49 
 50 //抽象工厂类，提供一个创建接口
 51 class TankFactory
 52 {
 53 public:
 54     //提供创建产品实例的接口，返回抽象产品类
 55     virtual Tank* createTank() = 0;
 56 };
 57 
 58 //具体的创建工厂类，使用抽象工厂类提供的接口，去创建具体的产品实例
 59 class Tank56Factory : public TankFactory
 60 {
 61 public:
 62     Tank* createTank() override
 63     {
 64         return new Tank56();
 65     }
 66 };
 67 
 68 //具体的创建工厂类，使用抽象工厂类提供的接口，去创建具体的产品实例
 69 class Tank96Factory : public TankFactory
 70 {
 71 public:
 72     Tank* createTank() override
 73     {
 74         return new Tank96();
 75     }
 76 };
 77 
 78 
 79 int main()
 80 {
 81     TankFactory* factory56 = new Tank56Factory();
 82     Tank* tank56 = factory56->createTank();
 83     tank56->type();
 84     
 85     TankFactory* factory96 = new Tank96Factory();
 86     Tank* tank96 = factory96->createTank();
 87     tank96->type();
 88 
 89     delete tank96;
 90     tank96 = nullptr;
 91     delete factory96;
 92     factory96 = nullptr;
 93 
 94     delete tank56;
 95     tank56 = nullptr;
 96     delete factory56;
 97     factory56 = nullptr;
 98 
 99     return 0;
100 }

1.3、抽象工厂模式

抽象工厂模式提供创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

当存在多个产品系列，而客户端只使用一个系列的产品时，可以考虑使用抽象工厂模式。

缺点：当增加一个新系列的产品时，不仅需要现实具体的产品类，还需要增加一个新的创建接口，扩展相对困难。

复制代码

  1 /*
  2 * 关键代码：在一个工厂里聚合多个同类产品。
  3 * 以下代码以白色衣服和黑色衣服为例，白色衣服为一个产品系列，黑色衣服为一个产品系列。白色上衣搭配白色裤子，   黑色上衣搭配黑色裤字。每个系列的衣服由一个对应的工厂创建，这样一个工厂创建的衣服能保证衣服为同一个系列。
  4 */
  5 
  6 //抽象上衣类
  7 class Coat
  8 {
  9 public:
 10     virtual const string& color() = 0;
 11 };
 12 
 13 //黑色上衣类
 14 class BlackCoat : public Coat
 15 {
 16 public:
 17     BlackCoat():Coat(),m_strColor("Black Coat")
 18     {
 19     }
 20 
 21     const string& color() override
 22     {
 23         cout << m_strColor.data() << endl;
 24         return m_strColor;
 25     }
 26 private:
 27     string m_strColor;
 28 };
 29 
 30 //白色上衣类
 31 class WhiteCoat : public Coat
 32 {
 33 public:
 34     WhiteCoat():Coat(),m_strColor("White Coat")
 35     {
 36     }
 37     const string& color() override
 38     {
 39         cout << m_strColor.data() << endl;
 40         return m_strColor;
 41     }
 42 
 43 private:
 44     string m_strColor;
 45 }; 
 46 
 47 //抽象裤子类
 48 class Pants
 49 {
 50 public:
 51     virtual const string& color() = 0;
 52 };
 53 
 54 //黑色裤子类
 55 class BlackPants : public Pants
 56 {
 57 public:
 58     BlackPants():Pants(),m_strColor("Black Pants")
 59     {
 60     }
 61     const string& color() override
 62     {
 63         cout << m_strColor.data() << endl;
 64         return m_strColor;
 65     }
 66 
 67 private:
 68     string m_strColor;
 69 };
 70 
 71 //白色裤子类
 72 class WhitePants : public Pants
 73 {
 74 public:
 75     WhitePants():Pants(),m_strColor("White Pants")
 76     {
 77     }
 78     const string& color() override
 79     {
 80         cout << m_strColor.data() << endl;
 81         return m_strColor;
 82     }
 83 
 84 private:
 85     string m_strColor;
 86 };
 87 
 88 //抽象工厂类，提供衣服创建接口
 89 class Factory
 90 {
 91 public:
 92     //上衣创建接口，返回抽象上衣类
 93     virtual Coat* createCoat() = 0;
 94     //裤子创建接口，返回抽象裤子类
 95     virtual Pants* createPants() = 0;
 96 };
 97 
 98 //创建白色衣服的工厂类，具体实现创建白色上衣和白色裤子的接口
 99 class WhiteFactory : public Factory
100 {
101 public:
102     Coat* createCoat() override
103     {
104         return new WhiteCoat();
105     }
106 
107     Pants* createPants() override
108     {
109         return new WhitePants();
110     }
111 };
112 
113 //创建黑色衣服的工厂类，具体实现创建黑色上衣和白色裤子的接口
114 class BlackFactory : public Factory
115 {
116     Coat* createCoat() override
117     {
118         return new BlackCoat();
119     }
120 
121     Pants* createPants() override
122     {
123         return new BlackPants();
124     }
125 };

复制代码

2、策略模式

策略模式是指定义一系列的算法，把它们单独封装起来，并且使它们可以互相替换，使得算法可以独立于使用它的客户端而变化，也是说这些算法所完成的功能类型是一样的，对外接口也是一样的，只是不同的策略为引起环境角色环境角色表现出不同的行为。

相比于使用大量的if...else，使用策略模式可以降低复杂度，使得代码更容易维护。

缺点：可能需要定义大量的策略类，并且这些策略类都要提供给客户端。