设计模式(3)-对象创建型模式-Abstract Factory模式

本文主要是介绍设计模式(3)-对象创建型模式-Abstract Factory模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.对象创建型模式

1.3           Abstract Factory模式

1.3.1 需求

在以下情况可以使用Abstract Factory模式:

•  一个系统要独立于它的产品的创建、组合和表示时(这个需求和FactoryMethod类似)。

•  一个系统要由多个产品系列中的一个来配置时(这个需求也和Factory Method类似)。

•  当你要强调一系列相关的产品对象的设计以便进行联合使用时(这个需求表明一个工厂要创建多个相关的产品对象，是比FactoryMethod多的需求)。

•  当你提供一个产品类库，而只想显示它们的接口而不是实现时(这个也与FactoryMethod类似)。

根据这个适应场景可以看出，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory Method模式(经常直接成为工厂模式)是为一类对象提供创建接口或延迟对象的创建到子类中实现。

1.3.2功能

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

1.3.3 结构

 

•A b s t r a c t F a c t o r y ( Wi d g e t F a c t o r y )

                — 声明一个创建抽象产品对象的操作接口。

•C o n c r e t e F a c t o r y ( M o t i f Wi d g e t F a c t o r y ，P M Wid g e t F a c t o r y )

— 实现创建具体产品对象的操作。

•A b s t r a c t P r o d u c t ( Wi n d o w s，S c r o l l B a r )

— 为一类产品对象声明一个接口。

•C o n c r e t e P r o d u c t ( M o t i f Wi n d o w，M o t i f S c r o l l B a r )

— 定义一个将被相应的具体工厂创建的产品对象。

— 实现Ab s t r a c t P r o d u c t接口。

•C l i e n t

— 仅使用由Ab s t r a c t F a c t o r y和Ab s t r a c t P r o d u c t类声明的接口。

 

1.3.4 优缺点

优点：

1.      分类了具体的类：因为一个工厂封装创建产品对象的责任和过程，客户如果使用这种模式开发一个库，使用这个库的程序就叫做客户）将只需要通过抽象接口来操作实例。这意味着客户与产品类的实现分离，而且客户不需要知道产品类的具体名称,只需要知道要生成这个系列产品的工厂的名称。

2.      易于交换产品系列：在修改代码时，客户程序中只需要修改要生成产品的工厂，不需要修改其他任何代码。

3.      有利于产品的一致性：它保证了产品簇的相关性，当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

 

缺点：

难以支持新种类的产品. 这是因为A b s t r a c t F a c t or y接口确定了可以被创建的产品集合。 支持新种类的产品就需要扩展该工厂接口，这将涉及A b s t r a c t  F a c t o r y类及其所有子类的改变。正所谓鱼与熊掌，不可兼得啊，你打包组合在一起，自然要承担这个缺点。

 

1.35 例子-C++

//Product.h

#ifndef _PRODUCT_H_

#define _PRODUCT_H_

 

class AbstractProductA

{

public:

       virtual ~AbstractProductA();

protected:

       AbstractProductA();

private:

};

 

class AbstractProductB

{

public:

       virtual ~AbstractProductB();

protected:

       AbstractProductB();

private:

};

 

class ProductA1 :publicAbstractProductA

{

public:

       ProductA1();

       ~ProductA1();

protected: 

private:

};

 

class ProductA2 :publicAbstractProductA

{

public:

       ProductA2();

       ~ProductA2();

protected: 

private:

};

 

 

class ProductB1 :publicAbstractProductB

{

public:

       ProductB1();

       ~ProductB1();

protected:

private:

};

 

class ProductB2 :publicAbstractProductB

{

public:

       ProductB2();

       ~ProductB2();

protected: 

private:

};

 

 

#endif //~_PRODUCT_H_ECT_H_

 

//Product.cpp

#include"Product.h"

#include<iostream>

using namespace std;

AbstractProductA::AbstractProductA()

{}

 

AbstractProductA::~AbstractProductA()

{}

 

AbstractProductB::AbstractProductB()

{

}

 

AbstractProductB::~AbstractProductB()

{

}

 

ProductA1::ProductA1()

{

       cout << "ProductA1..."<< endl;

}

 

ProductA1::~ProductA1()

{

}

 

ProductA2::ProductA2()

{

       cout << "ProductA2..."<< endl;

}

 

ProductA2::~ProductA2()

{

}

 

ProductB1::ProductB1()

{

       cout << "ProductB1..."<< endl;

}

 

ProductB1::~ProductB1()

{

}

 

ProductB2::ProductB2()

{

       cout << "ProductB2..."<< endl;

}

 

ProductB2::~ProductB2()

{

}

 

//AbstractFactory.h

#ifndef _ABSTRACTFACTORY_H_

#define _ABSTRACTFACTORY_H_

class AbstractProductA;

class AbstractProductB;

 

class AbstractFactory

{

public:

       virtual ~AbstractFactory();

       virtual  AbstractProductA*

              CreateProductA() = 0;

       virtual  AbstractProductB*

              CreateProductB() = 0;

protected:

       AbstractFactory();

private:

};

 

class ConcreteFactory1 :publicAbstractFactory

{

public:

       ConcreteFactory1();

       ~ConcreteFactory1();

       AbstractProductA* CreateProductA();

       AbstractProductB* CreateProductB();

protected:

private:

};

 

class ConcreteFactory2 :publicAbstractFactory

{

public:

       ConcreteFactory2();

       ~ConcreteFactory2();

       AbstractProductA* CreateProductA();

       AbstractProductB* CreateProductB();

protected:

private:

};

 

#endif //~_ABSTRACTFACTORY_H_

 

//AbstractFactory.cpp

#include"AbstractFactory.h"

#include"Product.h"

#include<iostream>

using namespace std;

 

AbstractFactory::AbstractFactory()

{

}

 

AbstractFactory::~AbstractFactory()

{

}

 

ConcreteFactory1::ConcreteFactory1()

{

}

 

ConcreteFactory1::~ConcreteFactory1()

{

}

 

AbstractProductA*

ConcreteFactory1::CreateProductA()

{

       return newProductA1();

}

 

AbstractProductB*

ConcreteFactory1::CreateProductB()

{

       return newProductB1();

}

 

ConcreteFactory2::ConcreteFactory2()

{

}

 

ConcreteFactory2::~ConcreteFactory2()

{

}

 

AbstractProductA*

ConcreteFactory2::CreateProductA()

{

       return newProductA2();

}

 

AbstractProductB*

ConcreteFactory2::CreateProductB()

{

       return newProductB2();

}

 

//main.cpp

#include"AbstractFactory.h"

#include<iostream>

using namespace std;

int main(int argc, char*argv[])

{

       AbstractFactory* cf1 = new

              ConcreteFactory1();

       cf1->CreateProductA();

       cf1->CreateProductB();

       AbstractFactory* cf2 = new

              ConcreteFactory2();

       cf2->CreateProductA();

       cf2->CreateProductB();

       return 0;

}

1.3.5 例子-JAVA

 

package DesignPattern;

 

public class TestMain {

 

       /**

        * @param args

        */

       public static void main(String[] args){

              ClothesFactoryf=newShanghaiClothesFactory();

              //ClothesFactoryf=new BeijingClothesFactory();

 

              Trouserst = f.createTrousers(13, 14);

              System.out.println(t.getName());

             

              UpperClothesuc=f.createUpperClothes(13,14);

              System.out.println(uc.getName());

       }

}

 

这篇关于设计模式(3)-对象创建型模式-Abstract Factory模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---