设计模式C++实现——抽象工厂模式

优点：

      隔离具体类的生成，使得客户并不需要知道什么被创建。

      当一个产品族中的多个对象被设计成一起工作时，能够保证客户端时始终使用同一个产品族中的对象。

      增加新的产品很方便，不需要修改已有的系统，符合开闭原则。

缺点：

      增加新的产品等级结构麻烦，需要对原有系统进行很大的修改，甚至需要修改抽象层代码这显然会带来很大的不便，违背开闭原则。

#include <iostream>
using namespace std;

//按钮接口：抽象产品
class AbstractButton
{
public:
AbstractButton(){};
virtual ~AbstractButton(){};
virtual void display(){};
};

//Spring按钮：具体产品
class SpringButton: public AbstractButton
{
public:
SpringButton(){};
virtual ~SpringButton(){};
void display()
{
cout<<"显示浅绿色按钮"<<endl;
}
};

//Summer按钮：具体产品
class SummerButton: public AbstractButton
{
public:
SummerButton(){};
virtual ~SummerButton(){};
void display()
{
cout<<"显示浅绿色按钮"<<endl;
}
};

//文本框接口：抽象产品
class AbstractTextFiled  
{
public:
AbstractTextFiled(){};
virtual ~AbstractTextFiled(){};
virtual void dispaly(){}; 
};


//Spring文本框：具体产品
class SpringTextFiled: public AbstractTextFiled
{
public:
SpringTextFiled(){};
virtual ~SpringTextFiled(){};
void dispaly()
{
cout<<"显示绿色边框文本框"<<endl;
}
};

//Summer文本框：具体产品
class SummerTextFiled: public AbstractTextFiled
{
public:
SummerTextFiled(){};
virtual ~SummerTextFiled(){};
void dispaly()
{
cout<<"显示蓝色边框文本框"<<endl;
}
};


//组合框接口：抽象产品
class AbstractComboBox
{
public:
AbstractComboBox(){};
virtual ~AbstractComboBox(){};
virtual void display(){};
};

//Spring组合框：具体产品
class SpringComboBox: public AbstractComboBox
{
public:
SpringComboBox(){};
virtual ~SpringComboBox(){};
void display()
{
cout<<"显示绿色边框组合框"<<endl;
}
};

//Summer组合框：具体产品
class SummerComboBox: public AbstractComboBox
{
public:
SummerComboBox(){};
virtual ~SummerComboBox(){};
void display()
{
cout<<"显示蓝色边框组合框"<<endl;
}
};

//界面皮肤工厂接口：抽象工厂
class AbstractSkinFactory
{
public:
AbstractSkinFactory(){};
virtual ~AbstractSkinFactory(){};


virtual AbstractButton* createAbstractButton() = 0;
virtual AbstractTextFiled* createAbstractTextFiled() = 0;
virtual AbstractComboBox* createAbcstractComboBox() = 0;
};

//Spring皮肤工厂：具体工厂
class SpringSkinFactory: public AbstractSkinFactory
{
public:
SpringSkinFactory(){};
virtual ~SpringSkinFactory(){};


AbstractButton* createAbstractButton()
{
return new SpringButton();
}


AbstractTextFiled* createAbstractTextFiled()
{
return new SpringTextFiled();
}


AbstractComboBox* createAbcstractComboBox()
{
return new SpringComboBox();
}
};

//Summer皮肤工厂：具体工厂
class SummerSkinFactory: public AbstractSkinFactory
{
public:
SummerSkinFactory(){};
virtual ~SummerSkinFactory(){};


AbstractButton* createAbstractButton()
{
return new SummerButton();
}


AbstractTextFiled* createAbstractTextFiled()
{
return new SummerTextFiled();
}


AbstractComboBox* createAbcstractComboBox()
{
return new SummerComboBox();
}
};

//Client端
int main()
{
AbstractSkinFactory *fastory;
AbstractButton *bt;
AbstractTextFiled *tf;
AbstractComboBox *cb;


//这里我简单写一个，Java采用反射机制
fastory = new SpringSkinFactory();
bt = fastory->createAbstractButton();
tf = fastory->createAbstractTextFiled();
cb = fastory->createAbcstractComboBox();
bt->display();
tf->dispaly();
cb->display();

delete fastory;
delete bt;
delete tf;
delete cb;

return 0;

}