设计模式(一)
简单工厂模式
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的产品基类。