[创建型模式] 设计模式之抽象工厂模式(Abstract Factory Pattern）

灰太狼 2022-04-11 04:18 223阅读 0赞

为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：  
\[img\]http://images.cnblogs.com/cnblogs\_com/zhenyulu/Pic44.gif\[/img\]  
  
  
图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。  
  
引进抽象工厂模式  
  
所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。如果用图来描述的话，如下图：  
  
\[img\]http://images.cnblogs.com/cnblogs\_com/zhenyulu/Pic45.gif\[/img\]  
  
  
定义：  
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态,,当有多个抽象角色时，使用的一种工厂模式,它向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。  
  
注意：  
注意产品族的概念：  
是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的，形成一个二维的坐标系，水平坐标是产品等级结构，纵坐标是产品族。叫做相图。  
  
详细参考：  
http://baike.baidu.com/view/1580269.htm?fr=ala0\_1  
  
\[size=medium\]\[color=red\]  
我的理解是：  
A公司想找一个外包公司做一个项目，这个项目需要两个小组人员完成，  
  
  
B公司 A小组 B小组  
C公司 C小组 D小组  
  
那么每一个小组是一个抽象产品类，而一个公司就是一个抽象工厂类，  
  
  
如果和B公司合作，那么就用A小组， B小组，  
如果和C公司合作，那么就用C小组，D小组  
  
所以A公司只管和某一公司合作，而不必关心小组成员以及组成，这部分工作由被合作公司去协调解决  
  
\[/color\]\[/size\]  
  
  
示例：某人喜欢做什么  
注意看这“某人喜欢”与“做什么”，这可以理解为两个产品族，他们在逻辑上存在一定的关系，但又是绝对的相互独立，以下我们以“奶奶喜欢种苹果”、“爷爷喜欢种香蕉”的示例来说明。  
示例中有两个产品族，那我们首先得为这两个产品族建立相应的工厂，

某人喜欢
    public interface FamilyPerson {
       
        public void like();
    }
    
    种什么（以水果为例）
    public interface Fruit {
       
        public void plant();
    }
    好了，以上就定义了“某人喜欢”与“种什么”两个工厂了，后面再来分别定义他们的实现类，首先定义“某人”的爷爷、奶奶实现类：
    爷爷：
    public class GrandePa implements FamilyPerson {
       
        public void like() {
       
           System.out.println("Grandpa likes ");
        }
    }
    奶奶：
    public class GrandeMa implements FamilyPerson {
       
        public void like() {
       
           System.out.println("Grandma likes ");
        }
    }
    再定义“种什么”的苹果、香蕉实现类：
    苹果：
    public class Apple implements Fruit {
       
        public void plant() {
       
           System.out.println("Plant Apple.");
        }
    }
    香蕉：
    public class Banana implements Fruit {
       
        public void plant() {
       
           System.out.println("Plant Banana");
        }
    }
    好了，基础的工厂都有了，现在需要一个抽象工厂了，呵，就是同时引用多个基础工厂的工厂，定下“爱好”工厂如下：
    public interface Hobby {
       
        public Fruit getFruit();
        public FamilyPerson getFamilyPerson();
    }
    实现爷爷喜欢种香蕉：
    public class GrandePaHobby implements Hobby {
       
        public FamilyPerson getFamilyPerson() {
       
           return new GrandePa();
        }
        public Fruit getFruit() {
       
           return new Banana();
        }
    }
    实现奶奶喜欢种苹果：
    public class GrandeMaHobby implements Hobby {
       
        public FamilyPerson getFamilyPerson() {
       
           return new GrandeMa();
        }
        public Fruit getFruit() {
       
           return new Apple();
        }
    }
    一切OK，来个调用实例：
    public class Test1 {
       
        public static void main(String[] args) {
       
           Hobby hobby = new GrandeMaHobby();
           hobby.getFamilyPerson().like();
           hobby.getFruit().plant();
        }
    }
    输出：
    Grandma likes
    Plant Apple.

以下转载一下看到的一遍文章  
http://www.cnblogs.com/jiese/p/3156753.html  
  
AbstractFactory  
  
要创建一组相关或者相互依赖的对象  
  
作用：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。  
  
UML结构图：  
  
\[img\]http://images.cnitblog.com/blog/159936/201306/26160054-8c010d91d93e40d198bc5718af2c1007.x-png\[/img\]  
  
抽象基类：  
  
1）AbstractProductA、AbstractProductB：分别代表两种不同类型的产品，由具体的产品派生类对其实现  
  
2）AbstractFactory：抽象工厂类，提供创建两种产品的接口CreateProductA和CreateProductB，由派生的各个具体工厂类对其实现  
  
说明：  
  
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中  
  
Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂  
  
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n\*m个Factory模式的使用  
  
AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。

#ifndef _PRODUCT_H_
    #define _PRODUCT_H_
    
    //抽象基类AbstractProductA，代表A类产品的抽象
    class AbstractProductA
    {
       
    public:
        virtual ~AbstractProductA()=0;
        virtual void operation()=0;
    protected:
        AbstractProductA();//屏蔽构造函数
    };
    
    //派生类ProductA1，继承自AbstractProductA，A类产品的一种实现
    class ProductA1 : public AbstractProductA
    {
       
    public:
        ProductA1();
        virtual void operation();
        virtual ~ProductA1();
    };
    
    //派生类ProductA2，继承自AbstractProductA，A类产品的另一种实现
    class ProductA2:public AbstractProductA
    {
       
    public:
        ProductA2();
        virtual void operation();
        virtual ~ProductA2();
    };
    
    //抽象基类AbstractProductB，代表B类产品的抽象
    class AbstractProductB
    {
       
    public:
        virtual ~AbstractProductB()=0;
        virtual void operation()=0;
    protected:
        AbstractProductB();//屏蔽构造函数
    };
    
    //派生类ProductB1，继承自AbstractProductB，B类产品的一种实现
    class ProductB1:public AbstractProductB
    {
       
    public:
        ProductB1();
        virtual void operation();
        virtual ~ProductB1();
    };
    
    //派生类ProductB2，继承自AbstractProductB，B类产品的另一种实现
    class ProductB2:public AbstractProductB
    {
       
    public:
        ProductB2();
        virtual void operation();
        virtual ~ProductB2();
    };
    
    
    #endif

#ifndef _FACTORY_H_
    #define _FACTORY_H_
    
    //AbstractFactory，工厂抽象基类，定义生产A类与B类产品的接口
    class AbstractProductA;
    class AbstractProductB;
    class AbstractFactory
    {
       
    public:
        virtual ~AbstractFactory()=0;
        virtual AbstractProductA* CreateProductA()=0;
        virtual AbstractProductB* CreateProductB()=0;
    protected:
        AbstractFactory();
    };
    
    //ConcreteFactory1，派生类，继承自AbstractFactory
    //实现继承的接口，生产产品A和B的一种实现
    class ConcreteFactory1:public AbstractFactory
    {
       
    public:
        ConcreteFactory1();
        ~ConcreteFactory1();
        virtual AbstractProductA* CreateProductA();
        virtual AbstractProductB* CreateProductB();
    };
    
    //ConcreteFactory2，派生类，继承自AbstractFactory
    //实现继承的接口，生产产品A和B的另一种实现
    class ConcreteFactory2:public AbstractFactory
    {
       
    public:
        ConcreteFactory2();
        ~ConcreteFactory2();
        virtual AbstractProductA* CreateProductA();
        virtual AbstractProductB* CreateProductB();
    };
    
    #endif

#include "Product.h"
    #include <iostream>
    
    using namespace std;
    
    //AbstractProductA
    AbstractProductA::AbstractProductA()
    {
       
        cout << "AbstractProductA..." << endl;
    }
    
    AbstractProductA::~AbstractProductA()
    {
       
        cout << "~AbstractProductA..." << endl;
    }
    
    //ProductA1
    ProductA1::ProductA1()
    {
       
        cout << "ProductA1..." << endl;
    }
    
    ProductA1::~ProductA1()
    {
       
        cout << "~ProductA1..." << endl;
    }
    
    void ProductA1::operation()
    {}
    
    //ProductA2
    ProductA2::ProductA2()
    {
       
        cout << "ProductA2..." << endl;
    }
    
    ProductA2::~ProductA2()
    {
       
        cout << "~ProductA2..." << endl;
    }
    
    void ProductA2::operation()
    {}
    
    //AbstractProductB
    AbstractProductB::AbstractProductB()
    {
       
        cout << "AbstractProductB..." << endl;
    }
    
    AbstractProductB::~AbstractProductB()
    {
       
        cout << "~AbstractProductB..." << endl;
    }
    
    //ProductB1
    ProductB1::ProductB1()
    {
       
        cout << "ProductB1..." << endl;
    }
    
    ProductB1::~ProductB1()
    {
       
        cout << "~ProductB1..." << endl;
    }
    
    void ProductB1::operation()
    {}
    
    //ProductB2
    ProductB2::ProductB2()
    {
       
        cout << "ProductB2..." << endl;
    }
    
    ProductB2::~ProductB2()
    {
       
        cout << "~ProductB2..." << endl;
    }
    
    void ProductB2::operation()
    {}

#include "Factory.h"
    #include "Product.h"
    #include <iostream>
    
    using namespace std;
    
    AbstractFactory::AbstractFactory()
    {
       
        cout << "AbstractFactory..." << endl;
    }
    
    AbstractFactory::~AbstractFactory()
    {
       
        cout << "~AbstractFactory..." << endl;
    }
    
    ConcreteFactory1::ConcreteFactory1()
    {
       
        cout << "ConcreteFactory1..." << endl;
    }
    
    ConcreteFactory1::~ConcreteFactory1()
    {
       
        cout << "~ConcreteFactory1..." << endl;
    }
    
    AbstractProductA* ConcreteFactory1::CreateProductA()
    {
       
        return new ProductA1();
    }
    
    AbstractProductB* ConcreteFactory1::CreateProductB()
    {
       
        return new ProductB1();
    }
    
    ConcreteFactory2::ConcreteFactory2()
    {
       
        cout << "ConcreteFactory2..." << endl;
    }
    
    ConcreteFactory2::~ConcreteFactory2()
    {
       
        cout << "~ConcreteFactory2..." << endl;
    }
    
    AbstractProductA* ConcreteFactory2::CreateProductA()
    {
       
        return new ProductA2();
    }
    
    AbstractProductB* ConcreteFactory2::CreateProductB()
    {
       
        return new ProductB2();
    }

#include <iostream>
    #include "Factory.h"
    #include "Product.h"
    
    using namespace std;
    
    int main()
    {
       
        AbstractFactory* fa1 = new ConcreteFactory1();
        AbstractProductA* a1 = fa1->CreateProductA();
        AbstractProductB* b1 = fa1->CreateProductB();
    
        cout << endl;
        AbstractFactory* fa2 = new ConcreteFactory2();
        AbstractProductA* a2 = fa2->CreateProductA();
        AbstractProductB* b2 = fa2->CreateProductB();
    
        cout << endl;
        delete fa1;
        delete a1;
        delete b1;
    
        cout << endl;
        delete fa2;
        delete a2;
        delete b2;
    
        return 0;
    }