《一》简单工厂模式
简单工厂模式是属于创建型模式,又叫做静态工厂方法(static Factory Method)模式,简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例.
简单工厂模式的实质:是由一个工厂类根据传入的参数,动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。打个比方假设有一个工厂,他能生产出A、B两种产品。当客户需要产品的时候一定要告诉共产是哪种产品,是A还是B。当新增加一种新产品的时候,那么就要去修改工厂的类。
简单工厂的缺点:当新增产品的时候就要去修改工厂的类,这就违反了开放封闭原则,(类、模块、函数)可以扩展,但是不可以修改
简单工厂模式原理:
class Product
{
public:
Product(string name) :mname(name){}
virtual ~Product(){}
virtual void operation() = 0;
protected:
string mname;
};
class ProductA :public Product
{
public:
ProductA(string name) :Product(name){}
void operation()
{
cout << mname << " operator xxxa" << endl;
}
};
class ProductB :public Product
{
public:
ProductB(string name) :Product(name){}
void operation()
{
cout << mname << " operator xxxb" << endl;
}
};
class ProductC : public Product
{
public:
ProductC(string name) :Product(name){}
void operation()
{
cout << mname << " operator xxxc" << endl;
}
};
class SimpleFactory
{
public:
Product* createProduct(int flag)
{
switch (flag)
{
case 1:
return new ProductA("A");
break;
case 2:
return new ProductB("B");
break;
default:
return NULL;
break;
}
}
};
int main()
{
SimpleFactory f;
Product* p = f.createProduct(2);//productB
p->operation();
return 0;
}
代码运行结果如下图:
《二》工厂方法模式:
所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。打个比方现在有A、B两种产品,那么久开两个工厂。工厂A负责生产A产品,工厂B负责生产B种产品。这时候客户不需要告诉工厂生产哪种产品了,只需要告诉工厂生产就可以了。
工厂模式原理:
工厂方法模式代码如下:
class Product
{
public:
Product(string name) :mname(name){}
virtual ~Product(){}
virtual void operation() = 0;
protected:
string mname;
};
class ProductA :public Product
{
public:
ProductA(string name) :Product(name){}
void operation()
{
cout << mname << " operator xxxa" << endl;
}
};
class ProductB :public Product
{
public:
ProductB(string name) :Product(name){}
void operation()
{
cout << mname << " operator xxxb" << endl;
}
};
class ProductC : public Product
{
public:
ProductC(string name) :Product(name){}
void operation()
{
cout << mname << " operator xxxc" << endl;
}
};
class Factory
{
public:
virtual ~Factory(){}
virtual Product* createProduct() = 0;
};
class FactoryA :public Factory
{
public:
Product* createProduct()
{
return new ProductA("A");
}
};
class FactoryB :public Factory
{
public:
Product* createProduct()
{
return new ProductB("B");
}
};
class FactoryC :public Factory
{
public:
Product* createProduct()
{
return new ProductC("C");
}
};
int main()
{
Factory* f = new FactoryC();
Product* p = f->createProduct();
p->operation();
return 0;
}
代码运行结果如下:
《三》抽象工厂模式
为什么要有抽象工厂模式,假如我们A产品中有A1和A2两种型号的厂品,B产品中有B1和B2两种型号的厂品,那怎么办,上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂,工厂A负责生产A1 、A2型号产品,B工厂负责生产B1、B2型号的产品。
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 适用性:一个系统要独立于它的产品的创建、组合和表示时。一个系统要由多个产品系列中的一个来配置时。当你要强调一系列相关的产品对象的设计以便进行联合使用时。当你提供一个产品类库,而只想显示它们的接口而不是实现时。
抽象工厂模式的原理图:
抽象工厂模式代码如下:
class ProductA
{
public:
ProductA(string name) :mname(name){}
virtual ~ProductA(){}
virtual void operation() = 0;
protected:
string mname;
};
class ProductA1 :public ProductA
{
public:
ProductA1(string name) :ProductA(name){}
void operation()
{
cout << mname << "operation a1" << endl;
}
};
class ProductA2 :public ProductA
{
public:
ProductA2(string name) :ProductA(name){}
void operation()
{
cout << mname << "operation a2" << endl;
}
};
class ProductB
{
public:
ProductB(string name) :mname(name){}
virtual ~ProductB(){}
virtual void operation() = 0;
protected:
string mname;
};
class ProductB1 :public ProductB
{
public:
ProductB1(string name) :ProductB(name){}
void operation()
{
cout << mname << "operation b1" << endl;
}
};
class ProductB2 :public ProductB
{
public:
ProductB2(string name) :ProductB(name){}
void operation()
{
cout << mname << "operation b2" << endl;
}
};
class AbstractFactory
{
public:
virtual ~AbstractFactory(){}
virtual ProductA* createProductA() = 0;
virtual ProductB* createProductB() = 0;
};
class Factory1 : public AbstractFactory
{
public:
virtual ProductA* createProductA()
{
return new ProductA1("a1");
}
virtual ProductB* createProductB()
{
return new ProductB1("b1");
}
};
class Factory2 : public AbstractFactory
{
public:
virtual ProductA* createProductA()
{
return new ProductA2("a2");
}
virtual ProductB* createProductB()
{
return new ProductB2("b2");
}
};
int main()
{
AbstractFactory* paf = new Factory2();
ProductB* pa = paf->createProductB();
pa->operation();
AbstractFactory* paf1 = new Factory1();
ProductA* pa1 = paf1->createProductA();
pa1->operation();
return 0;
}
代码运行结果如下: