设计模式-抽象工厂

设计模式-抽象工厂

产品族：一个品牌下面的所有产品；

产品等级：多个品牌下面的同种产品；

应用场景

抽象工厂后续的拓展是拓展产品等级，如果是拓展产品族则不建议使用抽象工厂模式

类图

代码

#include <iostream> 
using namespace std; 


class AbstractProductA 
{ 
public: 
    virtual ~AbstractProductA(){}; 
protected: 
    AbstractProductA(){

    }
}; 

class ProductA1:public AbstractProductA 
{ 
public: 
    ProductA1(){
        cout<<"ProductA1"<<endl;
    }
    ~ProductA1(){} 
}; 
class ProductA2:public AbstractProductA 
{ 
public: 
    ProductA2(){
        cout<<"ProductA2"<<endl;
    }
    ~ProductA2(){} 
};

//后续拓展ProductA3
class ProductA3:public AbstractProductA 
{ 
public: 
    ProductA3(){
        cout<<"ProductA3"<<endl;
    }
    ~ProductA3(){} 
}; 
class AbstractProductB 
{ 
public: 
    virtual ~AbstractProductB(){}; 
protected: 
    AbstractProductB(){}
};


class ProductB1:public AbstractProductB 
{ 
public: 
    ProductB1(){
        cout<<"ProductB1"<<endl;
    }
    ~ProductB1(){} 
}; 
class ProductB2:public AbstractProductB 
{ 
public: 
    ProductB2(){
        cout<<"ProductB2"<<endl;
    }
    ~ProductB2(){}; 
};

//后续拓展ProductB3
class ProductB3:public AbstractProductB 
{ 
public: 
    ProductB3(){
        cout<<"ProductB3"<<endl;
    }
    ~ProductB3(){}; 
};
class AbstractFactory 
{ 
public: 
    virtual ~AbstractFactory(){}; 
    virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
protected: 
    AbstractFactory(){}
private: 
}; 
class ConcreteFactory1:public AbstractFactory
{ 
public: 
    ConcreteFactory1(){}
    ~ConcreteFactory1(){} 
    AbstractProductA* CreateProductA(){
        return new ProductA1;
    }
    AbstractProductB* CreateProductB(){
        return new ProductB1;
    }

};

class ConcreteFactory2:public AbstractFactory
{ 
public: 
 ConcreteFactory2(){}
 ~ConcreteFactory2(){} 
 AbstractProductA* CreateProductA(){
    return new ProductA2;
 }
 AbstractProductB* CreateProductB(){
    return new ProductB2;
}
};
//后续拓展ConcreteFactory3
class ConcreteFactory3:public AbstractFactory
{ 
public: 
 ConcreteFactory3(){}
 ~ConcreteFactory3(){} 
 AbstractProductA* CreateProductA(){
    return new ProductA3;
 }
 AbstractProductB* CreateProductB(){
    return new ProductB3;
}
};
int main(int argc,char* argv[])
{ 
    AbstractFactory* cf1 = new ConcreteFactory1(); 
    cf1->CreateProductA(); 
    cf1->CreateProductB(); 


    AbstractFactory* cf2 = new ConcreteFactory2(); 
    cf2->CreateProductA(); 
    cf2->CreateProductB(); 
    //后续拓展
    AbstractFactory* cf3 = new ConcreteFactory3(); 
    cf3->CreateProductA(); 
    cf3->CreateProductB(); 
    return 0;
}

优点

个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象（将一个系列的产品统一一起创建）；

缺点

产品族扩展非常困难，要增加一个系列的某一产品，既要修改工厂抽象类里加代码，又修改具体的实现类里面加代码；
增加了系统的抽象性和理解难度；