[设计模式] 1/2 工程与抽象工程模式 factory & Abstrac Factory

转载 http://blog.csdn.net/wuzhekai1985

   软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》两本书。本文介绍工厂模式的实现。

       工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

#include<iostream>
using namespace std;

enum CTYPE {COREA, COREB};
class SingleCore
{
    public:
        virtual void Show() = 0;
};
// Core A 
class SingleCoreA: public SingleCore
{
    public:  
        void Show() { cout<<"SingleCore A"<<endl; }  
};  
//Core B
class SingleCoreB: public SingleCore  
{  
    public:  
        void Show() { cout<<"SingleCore B"<<endl; }  
};  
// unique factory, it can product two cores, distinct tow types by parameter type
class Factory  
{  
    public:   
        SingleCore* CreateSingleCore(enum CTYPE ctype)  
        {  
            if(ctype == COREA) //工程内部判断
                return new SingleCoreA(); //生产coreA
            else if(ctype == COREB)  
                return new SingleCoreB(); //生产coreB  
            else  
                return NULL;  
        }  
};  

int main()
{
    Factory* f = new Factory();

    SingleCore * sA = f->CreateSingleCore(COREA);
    sA->Show();

    SingleCore * sB = f->CreateSingleCore(COREB);
    sB->Show();

    return 0;
}

 这样设计的主要缺点之前也提到过，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

       听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

#include<iostream>
using namespace std;

class SingleCore
{
    public:
        virtual void Show() = 0;
};
// core A 
class SingleCoreA: public SingleCore
{
    public:
        void Show() { cout<<"SingleCore A"<<endl; }
};
// core B 
class SingleCoreB: public SingleCore  
{  
    public:  
        void Show() { cout<<"SingleCore B"<<endl; }   
};  
class Factory  
{  
    public:  
        virtual SingleCore* CreateSingleCore() = 0;
};  
// factory which produce coreA 
class FactoryA: public Factory  
{  
    public:  
        SingleCoreA* CreateSingleCore() { return new SingleCoreA; }   
};  
// factory which produce coreB 
class FactoryB: public Factory  
{  
    public:  
        SingleCoreB* CreateSingleCore() { return new SingleCoreB; }   
};

int main()
{
    Factory* fA = new FactoryA();
    Factory* fB = new FactoryB();

    SingleCore * sA = fA->CreateSingleCore();
    sA->Show();

    SingleCore * sB = fB->CreateSingleCore();
    sB->Show();

    return 0;
}

可以看出，Factory 模式对于对象的创建给予开发人员提供了很好的实现策略，但是Factory 模式仅仅局限于一类类（就是说 Product 是一类，有一个共同的基类），如果我们要
为不同类的类提供一个对象创建的接口，那就要用 AbstractFactory 了。

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

       既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

#include<iostream>
using namespace std;

// sing core 
class SingleCore
{
    public:
        virtual void Show() = 0;
};
class SingleCoreA: public SingleCore
{
    public:
        void Show() { cout<<"Single Core A"<<endl; }
};
class SingleCoreB :public SingleCore
{
    public:
        void Show() { cout<<"Single Core B"<<endl; }
};
// muitiple core
class MultiCore
{
    public:
        virtual void Show() = 0;
};
class MultiCoreA : public MultiCore
{
    public:
        void Show() { cout<<"Multi Core A"<<endl; }

};
class MultiCoreB : public MultiCore
{
    public:
        void Show() { cout<<"Multi Core B"<<endl; }
};
//factory  
class Factory
{
    public:
        virtual SingleCore* CreateSingleCore() = 0;
        virtual MultiCore* CreateMultiCore() = 0;
};
// facotryA, which only produce A sytle
class FactoryA :public Factory
{
    public:
        SingleCore* CreateSingleCore() { return new SingleCoreA(); }
        MultiCore* CreateMultiCore() { return new MultiCoreA(); }
};
// facotryB, which only produce B sytle
class FactoryB : public Factory
{
    public:
        SingleCore* CreateSingleCore() { return new SingleCoreB(); }
        MultiCore* CreateMultiCore() { return new MultiCoreB(); }
};

int main()
{
    Factory* fA = new FactoryA();
    Factory* fB = new FactoryB();

    SingleCore * sA = fA->CreateSingleCore();
    MultiCore * mA = fA->CreateMultiCore();
    sA->Show();
    mA->Show();

    SingleCore * sB = fB->CreateSingleCore();
    MultiCore * mB = fB->CreateMultiCore();
    sB->Show();
    mB->Show();

    return 0;
}
          

  至此，工厂模式介绍完了。利用Rational Rose 2003软件，给出三种工厂模式的UML图，加深印象。

         简单工厂模式的UML图：

         工厂方法的UML图：

         抽象工厂模式的UML图：

    转载请标明出处 http://blog.csdn.net/wuzhekai1985

抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象

Factory VS Abstrac Factory

 工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类可以创建多个具体产品类的实例。 
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。 
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个