设计模式之抽象工厂模式
抽象工厂模式是一种创建型设计模式，它提供了一种方式来封装一组具有共同主题的单独工厂。抽象工厂模式通过提供一个超级工厂创建其他工厂的接口，使得客户端使用抽象的接口操作具体对象，从而实现客户端与具体工厂类解耦。
使用C++实现抽象工厂模式（Abstract Factory）
下面是一个使用C++实现抽象工厂模式的例子：
# include<iostream>
# include<string>
// 抽象产品A
classAbstractProductA{
public:
virtual~AbstractProductA {}
virtualstd:: stringuse= 0;
};
// 抽象产品B
classAbstractProductB{
public:
virtual~AbstractProductB {}
virtualstd:: stringeat= 0;
};
// 具体产品A1
classProductA1: publicAbstractProductA {
public:
std:: stringuseoverride{
return"Using Product A1";
}
};
// 具体产品A2
classProductA2: publicAbstractProductA {
public:
std:: stringuseoverride{
return"Using Product A2";
}
};
// 具体产品B1
classProductB1: publicAbstractProductB {
public:
std:: stringeatoverride{
return"Eating Product B1";
}
};
// 具体产品B2
classProductB2: publicAbstractProductB {
public:
std:: stringeatoverride{
return"Eating Product B2";
}
};
// 抽象工厂
classAbstractFactory{
public:
virtual~AbstractFactory {}
virtualAbstractProductA* createProductA= 0;
virtualAbstractProductB* createProductB= 0;
};
// 具体工厂1
classFactory1: publicAbstractFactory {
public:
AbstractProductA* createProductAoverride{
returnnewProductA1;
}
AbstractProductB* createProductBoverride{
returnnewProductB1;
}
};
// 具体工厂2
classFactory2: publicAbstractFactory {
public:
AbstractProductA* createProductAoverride{
returnnewProductA2;
}
AbstractProductB* createProductBoverride{
returnnewProductB2;
}
};
// 客户端代码
voidclientCode(AbstractFactory* factory){
AbstractProductA* productA = factory->createProductA;
AbstractProductB* productB = factory->createProductB;
std:: cout<< productA->use << std:: endl;
std:: cout<< productB->eat << std:: endl;
deleteproductA;
deleteproductB;
}
intmain{
AbstractFactory* factory1 = newFactory1;
AbstractFactory* factory2 = newFactory2;
std:: cout<< "Using the products created by Factory 1:"<< std:: endl;
clientCode(factory1);
std:: cout<< "Using the products created by Factory 2:"<< std:: endl;
clientCode(factory2);
deletefactory1;
deletefactory2;
return0;
}
运行结果如下所示：
在这个例子中，我们定义了两个抽象产品类AbstractProductA和AbstractProductB，以及两个具体产品类ProductA1和ProductA2、ProductB1和ProductB2。我们还定义了一个抽象工厂类AbstractFactory，以及两个具体工厂类Factory1和Factory2。
客户端代码使用抽象工厂接口来创建具体产品，并使用这些产品。通过使用抽象工厂模式，我们可以在不改变客户端代码的情况下，改变具体工厂类和具体产品类。
使用C#实现抽象工厂模式（Abstract Factory）namespaceAbstract_Factory_Pattern
{
internalclassProgram
{
publicinterfaceILaptop
{
voidShowSpecs( ) ;
}
publicinterfaceIDesktop
{
voidShowSpecs( ) ;
}
// Apple 品牌的产品
publicclassAppleLaptop: ILaptop
{
publicvoidShowSpecs( )
{
Console.WriteLine( "Apple Laptop Specifications");
}
}
publicclassAppleDesktop: IDesktop
{
publicvoidShowSpecs( )
{
Console.WriteLine( "Apple Desktop Specifications");
}
}
// Lenovo 品牌的产品
publicclassLenovoLaptop: ILaptop
{
publicvoidShowSpecs( )
{
Console.WriteLine( "Lenovo Laptop Specifications");
}
}
publicclassLenovoDesktop: IDesktop
{
publicvoidShowSpecs( )
{
Console.WriteLine( "Lenovo Desktop Specifications");
}
}
publicinterfaceIComputerFactory
{
ILaptop CreateLaptop( ) ;
IDesktop CreateDesktop( ) ;
}
publicclassAppleFactory: IComputerFactory
{
publicILaptop CreateLaptop( )
{
returnnewAppleLaptop;
}
publicIDesktop CreateDesktop( )
{
returnnewAppleDesktop;
}
}
publicclassLenovoFactory: IComputerFactory
{
publicILaptop CreateLaptop( )
{
returnnewLenovoLaptop;
}
publicIDesktop CreateDesktop( )
{
returnnewLenovoDesktop;
}
}
staticvoidMain( string[] args )
{
// 创建工厂
IComputerFactory appleFactory = newAppleFactory;
IComputerFactory lenovoFactory = newLenovoFactory;
// 创建 Apple 产品的笔记本和台式机
ILaptop appleLaptop = appleFactory.CreateLaptop;
IDesktop appleDesktop = appleFactory.CreateDesktop;
appleLaptop.ShowSpecs;
appleDesktop.ShowSpecs;
// 创建 Lenovo 产品的笔记本和台式机
ILaptop lenovoLaptop = lenovoFactory.CreateLaptop;
IDesktop lenovoDesktop = lenovoFactory.CreateDesktop;
lenovoLaptop.ShowSpecs;
lenovoDesktop.ShowSpecs;
}
}
}
运行结果如下所示：
publicclassAbstract_Factory_Pattern
{
publicinterfaceLaptop
{
voidshowSpecs;
}
publicinterfaceDesktop
{
voidshowSpecs;
}
// Apple 品牌的产品
publicclassAppleLaptopimplementsLaptop{
@Override
publicvoidshowSpecs{
System.out.println( "Apple Laptop Specifications");
}
}
publicclassAppleDesktopimplementsDesktop{
@Override
publicvoidshowSpecs{
System.out.println( "Apple Desktop Specifications");
}
}
// Lenovo 品牌的产品
publicclassLenovoLaptopimplementsLaptop{
@Override
publicvoidshowSpecs{
System.out.println( "Lenovo Laptop Specifications");
}
}
publicclassLenovoDesktopimplementsDesktop{
@Override
publicvoidshowSpecs{
System.out.println( "Lenovo Desktop Specifications");
}
}
publicinterfaceComputerFactory{
Laptop createLaptop;
Desktop createDesktop;
}
publicclassAppleFactoryimplementsComputerFactory{
@Override
publicLaptop createLaptop{
returnnewAppleLaptop;
}
@Override
publicDesktop createDesktop{
returnnewAppleDesktop;
}
}
publicclassLenovoFactoryimplementsComputerFactory{
@Override
publicLaptop createLaptop{
returnnewLenovoLaptop;
}
@Override
publicDesktop createDesktop{
returnnewLenovoDesktop;
}
}
publicvoidtest
{
// 创建工厂
ComputerFactory appleFactory = newAppleFactory;
ComputerFactory lenovoFactory = newLenovoFactory;
// 创建 Apple 产品的笔记本和台式机
Laptop appleLaptop = appleFactory.createLaptop;
Desktop appleDesktop = appleFactory.createDesktop;
appleLaptop.showSpecs;
appleDesktop.showSpecs;
// 创建 Lenovo 产品的笔记本和台式机
Laptop lenovoLaptop = lenovoFactory.createLaptop;
Desktop lenovoDesktop = lenovoFactory.createDesktop;
lenovoLaptop.showSpecs;
lenovoDesktop.showSpecs;
}
publicstaticvoidmain(String[] args){
Abstract_Factory_Pattern afp = newAbstract_Factory_Pattern;
afp.test;
}
}
运行结果如下所示：
责任编辑：