设计模式(一)
简单工厂模式
client | 客户端,通过工厂类来创建对象,通过接口(抽象父类)来实现功能。 |
---|---|
Api | 产品基类(抽象父类) |
Factory | 工厂,根据输入参数来创建不同的实例对象。 |
Impl | 产品子类(用于实例化的子类) |
- 主要实现了两个功能:
- 定义了对象的接口——Api
- 封装了对象的创建——Factory
- 代码实现
/*类的设计*/
class Api {
virtual operation();
};
//产品A
class ImplA:public Api{
operation(){......};
};
//产品B
class ImplB:public Api{
operation(){......};
};
//工厂类
class Factory {
Api* createProduct(int i){
case 0:return new ImplA;
case 1:return new ImplB;
}
};
/*类的使用*/
int mian{
Factory *fac=new Factory(); //创建工厂
Api *implA=fac->createProduct(0); //创建产品A
Api *implB=fac->createProduct(1); //创建产品B
implA->operation(); //产品A的功能
implB->operation(); //产品B的功能
}
- 分析
- 避免使用过多的new来实例化产品子类,提高了可读性且便于维护。
- 实现了客户端和具体实现类的解耦,让客户端能够真正的面向接口编程。
工厂模式
Clients | 客户端,通过工厂子类来创建对象,通过Product接口来实现功能 |
---|---|
Product | 产品基类(抽象父类) |
ImplProduct | 产品子类(用于实例化对象) |
Factory | 工厂,提供创建对象的接口 |
ImplFactory | 工厂子类,用于实例化不同的产品 |
- 主要功能
- 定义了对象的接口,封装了对象的创建
- 使得具体化子类的工作延迟到了子类中,更容易拓展新的产品子类。
- 代码实现
/*类的设计*/
class Product{
virtual operation()=0;
};
//产品A
class ImplProductA:public product{
operation(){......};
};
//产品B
class ImplProductB:public product{
operation(){......};
};
//工厂接口
class Factory {
virtual CreateProduct();
};
//工厂A
class ImplFactoryA:public factory{
CreateProduct(){
return new ImplProductA;
}
};
//工厂B
class ImplFactoryB:public factory{
CreateProduct(){
return new ImplProductB;
}
};
/*类的使用*/
int main(){
Factory *fac1=new ImplFactoryA();
Factory *fac2=new ImplFactoryB();
Product *ImplA=fac1->CreateProduct();
Product *ImplB=fac2->CreateProduct();
ImplA->operation();
ImplB->operation():
}
3.分析
- 这种模式下,增加新的产品只需要增加新的工厂子类和新的产品子类。对原有的体系没有冲击。
- 这是“依赖倒置原则”的体现:要依赖抽象,不要依赖具类
抽象工厂模式
- 主要功能
- 为创建一组(有多类)相关或依赖的对象提供创建接口。
- 着重于产品簇的实现
- 代码
/*类的设计*/
class AbstractProductA{
virtual operation1();
};
//产品A1
class ImplProductA1:public AbstractProductA {
operation1(){......};
};
//产品A2
class ImplProductA2:public AbstractProductA {
operation1(){......};
};
class AbstractProductB{
virtual operation2();
};
//产品B1
class ImplProductB1:public AbstractProductB {
operation2(){......};
};
//产品B2
class ImplProductB2:public AbstractProductB {
operation2(){......};
};
class AbstractFactory{
virtual CreateProductA();
virtual CreateProductB();
};
class ImplFactory1:public AbstractFactory {
CreateProductA();
CreateProductB();
};
class ImplFactory2:public AbstractFactory {
CreateProductA();
CreateProductB();
};
/*类的使用*/
int main(){
AbstractFactory *fac1=new ImplFactory1();
AbstractFactory *fac2=new ImplFactory2();
AbstractProduct *A1=fac1->CreateProductA();
AbstractProduct *B1=fac1->CreateProductB();
AbstractProduct *A2=fac1->CreateProductA();
AbstractProduct *B2=fac1->CreateProductB();
A1->operation1();
B1->operation2();
A2->operation1();
B2->operation2();
}
- 分析
- 当只有一种产品基类时,抽象工厂模式退化为工厂模式。
总结
上述三种设计模式其基本功能都是定义了对象的接口,封装了对象的实现。尽可能的保证客户端代码的实现依赖于抽象而不是具体实现。
简单工厂模式: 在单个的工厂类里面:通过不同参数(或者重载,或者模板参数)来实例化不同的产品子类。
工厂模式: 定义抽象工厂,根据不同的子类工厂来实例化不同的产品子类。
抽象工厂模式: 对应于产品簇的实现,一大特征就是有着大于1的产品基类。