设计模式学习--抽象工厂模式

抽象工厂模式是对象创建形模式的一种。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。总的来说就是当发现需要创建一系列的对象，而此时发现耦合又高，为了以后的可扩展性，可以使用该模式。该模式的UML图如下：

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体类
适用性：1 一个系统要独立于它的产品的创建，组合和表示时；
2 一个系统要由多个产品系列中的一个配置时；
3 当你提供一个产品类时，而只是想表示他们的接口而不是实现时；
协作 ：通常在运行的时刻创建一个ConcreateFactory的实列，为创建不同的产品，客户应使用不同的具体工厂。AbstractoryFactory把创建产品对象的任务推迟到他的子类
优缺点 优点
1 分离了具体的类，客户与类的实现分离，产品的类名也不出现的客户的代码当中
2 易与交换产品系列
3 有利于产品的一致性
缺点
1 难于支持新的 产品 ，因为抽象工厂类的接口已经写好了，要实现另外的产品必须要修改抽象工厂的类的接
口和增加新的产品类
下面是以假设生产人种为例，三种肤色的人种，性别有男女 例子：
首先是UML图：

下面是实现，首先是人种的接口类Human

#pragma once
//人类接口
class Human
{
public:
    //相应的人种颜色
    virtual void getColor();
    //说话
    virtual void talk();
    //性别
    virtual void getSex();
private:
};
#include "Human.h"
void Human::getColor()
{

}

void Human::talk()
{

}

void Human::getSex()
{

}
//具体的黑色人种
//AbstractBlackHuman.h
#pragma once

#include "Human.h"
#include <iostream>

class AbstractBlackHuman : public Human
{
public:
    AbstractBlackHuman();
    ~AbstractBlackHuman();

    void getColor();
    void talk();
private:
};

#include "AbstractBlackHuman.h"

using namespace std;

AbstractBlackHuman::AbstractBlackHuman()
{
}

AbstractBlackHuman::~AbstractBlackHuman()
{
}

void AbstractBlackHuman::getColor()
{
    cout << "黑色人种的皮肤颜色是黑色的" <<endl;
}

void AbstractBlackHuman::talk()
{
    cout << "黑色人种一般说的是多字节" << endl;
}
//黑色女性
#pragma once
#include "AbstractBlackHuman.h"
#include <iostream>

class FemaleBlackHuman : public AbstractBlackHuman
{
public:
    FemaleBlackHuman();
    ~FemaleBlackHuman();
    void getSex();
private:

};
#include "FemaleBlackHuman.h"

using namespace std;

FemaleBlackHuman::FemaleBlackHuman()
{
}

FemaleBlackHuman::~FemaleBlackHuman()
{
}

void FemaleBlackHuman::getSex()
{
    cout << "黑色女性" << endl;
}
//黑色男性
#pragma once
#include "AbstractBlackHuman.h"
#include <iostream>

class MaleBlackHuman : public AbstractBlackHuman
{
public:
    MaleBlackHuman();
    ~MaleBlackHuman();
    void getSex();
private:

};
#include "MaleBlackHuman.h"
using namespace std;

MaleBlackHuman::MaleBlackHuman()
{
}

MaleBlackHuman::~MaleBlackHuman()
{
}

void MaleBlackHuman::getSex()
{
    cout << "黑色男性" << endl;
}


//白色人种
//AbstractWhiteHuman.h
#pragma once

#include "Human.h"
#include <iostream>

class AbstractWhiteHuman : public Human
{
public:
    AbstractWhiteHuman();
    ~AbstractWhiteHuman();
    void getColor();
    void talk();
private:
};

#include "AbstractWhiteHuman.h"

using namespace std;

AbstractWhiteHuman::AbstractWhiteHuman()
{
}

AbstractWhiteHuman::~AbstractWhiteHuman()
{
}

void AbstractWhiteHuman::getColor()
{
    cout << "白色人种的皮肤颜色是白色的" << endl;
}

void AbstractWhiteHuman::talk()
{
    cout << "白色人种一般说的是单字节" << endl;
}
//白色女性
#pragma once
#include "AbstractWhiteHuman.h"
#include <iostream>
class FemaleWhiteHuman : public AbstractWhiteHuman
{
public:
    FemaleWhiteHuman();
    ~FemaleWhiteHuman();
    void getSex();
private:
};

#include "FemaleWhiteHuman.h"

using namespace std;


FemaleWhiteHuman::FemaleWhiteHuman()
{
}

FemaleWhiteHuman::~FemaleWhiteHuman()
{
}

void FemaleWhiteHuman::getSex()
{
    cout << "白色女性" << endl;
}
//白色男性
#pragma once
#include "AbstractWhiteHuman.h"
#include <iostream>
class MaleWhiteHuman : public AbstractWhiteHuman
{
public:
    MaleWhiteHuman();
    ~MaleWhiteHuman();
    void getSex();
private:
};

#include "MaleWhiteHuman.h"

using namespace std;

MaleWhiteHuman::MaleWhiteHuman()
{
}

MaleWhiteHuman::~MaleWhiteHuman()
{
}

void MaleWhiteHuman::getSex()
{
    cout << "白色男性" << endl;
}

//黄色人种
//AbstractYellowHuman.h
#pragma once

#include "Human.h"
#include <iostream>

class AbstractYellowHuman : public Human
{
public:
    AbstractYellowHuman();
    ~AbstractYellowHuman();
    void getColor();
    void talk();
private:
};

#include "AbstractYellowHuman.h"

using namespace std;

AbstractYellowHuman::AbstractYellowHuman()
{
}

AbstractYellowHuman::~AbstractYellowHuman()
{
}

void AbstractYellowHuman::getColor()
{
    cout << "黄色人种的皮肤颜色是黄色的" << endl;
}

void AbstractYellowHuman::talk()
{
    cout << "黄色人种一般说的是双字节" << endl;
}
//黄色女性
#pragma once
#include "AbstractYellowHuman.h"
#include <iostream>
class FemaleYellowHuman : public AbstractYellowHuman
{
public:
    FemaleYellowHuman();
    ~FemaleYellowHuman();
    void getSex();
private:
};
#include "FemaleYellowHuman.h"

using namespace std;

FemaleYellowHuman::FemaleYellowHuman()
{
}

FemaleYellowHuman::~FemaleYellowHuman()
{
}

void FemaleYellowHuman::getSex()
{
    cout << "黄色女性" << endl;
}
//黄色男性
#pragma once
#include "AbstractYellowHuman.h"
#include <iostream>
class MaleYellowHuman : public AbstractYellowHuman
{
public:
    MaleYellowHuman();
    ~MaleYellowHuman();
    void getSex();
private:
};
#include "MaleYellowHuman.h"

using namespace std;

MaleYellowHuman::MaleYellowHuman()
{
}

MaleYellowHuman::~MaleYellowHuman()
{
}

void MaleYellowHuman::getSex()
{
    cout << "黄色男性" << endl;
}

以上是产品的信息类，都是继承与Human类，Human作为人类的抽象接口。接下来就是工厂类，工厂类也有一个抽象的接口HumanFactory，采用纯虚函数：

#pragma once

#include "Human.h"


class HumanFactory
{
public:
    HumanFactory();
    ~HumanFactory();
    virtual Human* createBlackHuman() = 0;
    virtual Human* createWhiteHuman() = 0;
    virtual Human* createYellowHuman() = 0;
private:
};
//男性工厂类，返回三种人种的男性
#pragma once
#include "HumanFactory.h"
#include "MaleBlackHuman.h"
#include "MaleWhiteHuman.h"
#include "MaleYellowHuman.h"

class MaleFactory : public HumanFactory
{
public:
    MaleFactory();
    ~MaleFactory();
    Human* createBlackHuman();
    Human* createWhiteHuman();
    Human* createYellowHuman();
private:
};

#include "MaleFactory.h"
MaleFactory::MaleFactory()
{
}

MaleFactory::~MaleFactory()
{
}

Human* MaleFactory::createBlackHuman()
{
    return new MaleBlackHuman();
}

Human* MaleFactory::createWhiteHuman()
{
    return new MaleWhiteHuman();
}

Human* MaleFactory::createYellowHuman()
{
    return new MaleYellowHuman();
}
//女性产品的工厂类，返回三种人种的女性类
#pragma once
#include "HumanFactory.h"
#include "FemaleBlackHuman.h"
#include "FemaleWhiteHuman.h"
#include "FemaleYellowHuman.h"

class FemaleFactory : public HumanFactory
{
public:
    FemaleFactory();
    ~FemaleFactory();
    Human* createBlackHuman();
    Human* createWhiteHuman();
    Human* createYellowHuman();
private:
};

#include "FemaleFactory.h"

FemaleFactory::FemaleFactory()
{
}

FemaleFactory::~FemaleFactory()
{
}

Human* FemaleFactory::createBlackHuman()
{
    return new FemaleBlackHuman();
}

Human* FemaleFactory::createWhiteHuman()
{
    return new FemaleWhiteHuman();
}

Human* FemaleFactory::createYellowHuman()
{
    return new FemaleYellowHuman();
}

产品类和工厂类的实现完成了，接下来就客户调用的方法了，

#include "stdafx.h"
#include "Human.h"
#include "HumanFactory.h"
#include "FemaleFactory.h"
#include "MaleFactory.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
   //生产女性工厂
    HumanFactory* femaleFactory = new FemaleFactory();
    //女性工厂生产出的黑色皮肤的女性
    Human* femaleBlackHuam = femaleFactory->createBlackHuman();
    femaleBlackHuam->getColor();
    femaleBlackHuam->getSex();
    femaleBlackHuam->talk();
    //男性工厂
    HumanFactory* maleFactory = new MaleFactory();
    //男性工厂生产出的黑色皮肤的男性
    Human* maleBlackHuame = maleFactory->createBlackHuman();
    maleBlackHuame->getColor();
    maleBlackHuame->getSex();
    maleBlackHuame->talk();
    return 0;
}

抽象工厂的学习先告一段落，以后有更好的理解的时候，回来修改。