设计模式（一）

设计模式（一）

简单工厂模式

client	客户端，通过工厂类来创建对象，通过接口（抽象父类）来实现功能。
Api	产品基类（抽象父类）
Factory	工厂，根据输入参数来创建不同的实例对象。
Impl	产品子类（用于实例化的子类）

1. 主要实现了两个功能：

• 定义了对象的接口——Api
• 封装了对象的创建——Factory

2. 代码实现

/*类的设计*/
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的功能
}

3. 分析

• 避免使用过多的new来实例化产品子类，提高了可读性且便于维护。
• 实现了客户端和具体实现类的解耦，让客户端能够真正的面向接口编程。

工厂模式

Clients	客户端，通过工厂子类来创建对象，通过Product接口来实现功能
Product	产品基类（抽象父类）
ImplProduct	产品子类（用于实例化对象）
Factory	工厂，提供创建对象的接口
ImplFactory	工厂子类，用于实例化不同的产品

1. 主要功能

• 定义了对象的接口，封装了对象的创建
• 使得具体化子类的工作延迟到了子类中，更容易拓展新的产品子类。

2. 代码实现

/*类的设计*/
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.分析

• 这种模式下，增加新的产品只需要增加新的工厂子类和新的产品子类。对原有的体系没有冲击。
• 这是“依赖倒置原则”的体现：要依赖抽象，不要依赖具类

抽象工厂模式

1. 主要功能

• 为创建一组（有多类）相关或依赖的对象提供创建接口。
• 着重于产品簇的实现

2. 代码

/*类的设计*/
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();	
}

3. 分析

• 当只有一种产品基类时，抽象工厂模式退化为工厂模式。

总结

​ 上述三种设计模式其基本功能都是定义了对象的接口，封装了对象的实现。尽可能的保证客户端代码的实现依赖于抽象而不是具体实现。

简单工厂模式： 在单个的工厂类里面：通过不同参数（或者重载，或者模板参数）来实例化不同的产品子类。

工厂模式： 定义抽象工厂，根据不同的子类工厂来实例化不同的产品子类。

抽象工厂模式： 对应于产品簇的实现，一大特征就是有着大于1的产品基类。