对象建立型模式------Abstract Factory(抽象工厂）

时间 2019-11-12

标签对象建立模式 abstract factory 抽象工厂繁體版

原文原文链接

1. 意图
    提供一个建立一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2. 别名
    Kit
3. 动机
      假设咱们要开发一款游戏，固然为了吸引更多的人玩，游戏难度不能太大（让你们都没有信心了，估计游戏也就没有前途了），可是也不能太简单（没有挑战性也不符合玩家的心理）。因而咱们就能够采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每一个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才能够过关。做为开发者，咱们就不得不建立怪物的类，而后初级怪物、中级怪物等都继承自怪物类（固然不一样种类的则须要另建立类，可是模式相同）。在每一个关卡，咱们都要建立怪物的实例，例如初级就建立初级怪物（有不少种类）、中级建立中级怪物等。能够想象在这个系统中，将会有成千上万的怪物实例要建立，问题是还要保证建立的时候不会出错:初级不能建立 BT 级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不能够。
     AbstractFactory 模式就是用来解决这类问题的：要建立一组相关或者相互依赖的对象。 ios

4.适用性

①一个系统要独立于它的产品的建立、组合和表示时。

  ②一个系统要由多个产品系列中的一个来配置时。
  ③当你要强调一系列相关的产品对象的设计以便进行联合使用时。
  ④当你提供一个产品类库，而只想显示它们的接口而不是实现时。web

5.参与者

①AbstractFactory(WidgetFactory)：声明一个建立抽象产品对象的操做接口。

  ②Concreteactory(MotifWidgetFactory，PMWidgetFactory):实现建立具体产品对象的操做。
  ③AbstractProduct(Windows，ScrollBar):为一类产品对象声明一个接口。
  ④ConcreteProduct(MotifWindow，MotifScrollBar):定义一个将被相应的具体工厂建立的产品对象;实现AbstractProduct接口。
  ⑤Client:仅使用由AbstractFactory和AbstractProduct类声明的接口。设计模式

6.协做

①一般在运行时刻建立一个ConcreteFactroy类的实例。这一具体的工厂建立具备特定实现的产品对象。为建立不一样的产品对象，客户应使用不一样的具体工厂。 ②AbstractFactory将产品对象的建立延迟到它的ConcreteFactory子类。 7.优缺点

①它分离了具体的类AbstractFactory模式帮助你控制一个应用建立的对象的类。由于一个工厂封装建立产品对象的责任和过程，它将客户与类的实现分离。客户经过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出如今客户代码中。

②它使得易于交换产品系列一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂便可使用不一样的产品配置，这是由于一个抽象工厂建立了一个完整的产品系列，因此整个产品系列会马上改变。在咱们的用户界面的例子中，咱们仅需转换到相应的工厂对象并从新建立接口，就可实现从Motif窗口组件转换为Presentation Manager窗口组件。 ③它有利于产品的一致性当一个系列中的产品对象被设计成一块儿工做时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而AbstractFactory很容易实现这一点。 ④难以支持新种类的产品难以扩展抽象工厂以生产新种类的产品。这是由于AbstractFactory接口肯定了能够被建立的产品集合。支持新种类的产品就须要扩展该工厂接口，这将涉及AbstractFactory类及其全部子类的改变。咱们会在实现一节讨论这个问题的一个解决办法。

8.讨论

AbstractFactory 模式和 Factory 模式的区别是初学（使用）设计模式时候的一个容易引发困惑的地方。实际上，AbstractFactory 模式是为建立一组（有多类）相关或依赖的对象提供建立接口，而Factory 模式正如我在相应的文档中分析的是为一类对象提供建立接口或延迟对象的建立到子类中实现。而且能够看到，AbstractFactory 模式一般都是使用 Factory 模式实现（ConcreteFactory1 ）。

#include<iostream>
class AbstractProductA{
public:
                 virtual ~ AbstractProductA(){}
protected:
                AbstractProductA(){}
};
class AbstractProductB{
public:
                 virtual ~ AbstractProductB(){}
protected:
                AbstractProductB(){}
};
class ProductA1:public AbstractProductA{
public:
                ProductA1(){std::cout<< "ProductA1..."<<std::endl;}
};
class ProductA2:public AbstractProductA{
                 public:
                ProductA2(){std::cout<< "ProductA2..."<<std::endl;}
};
class ProductB1:public AbstractProductB{
                 public:
                ProductB1(){std::cout<< "ProductB1..."<<std::endl;}
};
class ProductB2:public AbstractProductB{
                 public:
                ProductB2(){std::cout<< "ProductB2..."<<std::endl;}
};
class AbstractFactory{
public:
                 virtual ~AbstractFactory(){}
                 virtual AbstractProductA* CreateProductA()=0;
                 virtual AbstractProductB* CreateProductB()=0;
protected:
                AbstractFactory(){}
};
class ConcreteFactory1:public AbstractFactory{
public:
                AbstractProductA* CreateProductA(){ return new ProductA1();}
                AbstractProductB* CreateProductB(){ return new ProductB1();}
};
class ConcreteFactory2:public AbstractFactory{
public:
                AbstractProductA* CreateProductA(){ return new ProductA2();}
                AbstractProductB* CreateProductB(){ return new ProductB2();}
};
int main(){
                AbstractFactory * cf1 = new ConcreteFactory1();
                cf1->CreateProductA();
                cf1->CreateProductB();
                AbstractFactory * cf2 = new ConcreteFactory2();
                cf2->CreateProductA();
                cf2->CreateProductB();
}