设计模式之抽象工厂模式

抽象工厂模式针对产品族，不针对产品等级

#include<iostream>
using namespace std;
#include<string>

//简单工厂不符合开闭原则，所以这里不把创建每个水果对象放在一个工厂里，而是把创建工厂抽象出来，每次创建一个具体水果由每个对象工厂自己常见，达到开闭原则。

//但是工厂模式由弊端，每次新建一个对象就要新建一个工厂类，类多了就很麻烦

//抽象工厂模式针对的是产品族，满足开闭原则，不针对产品等级，不满足开闭原则

//抽象苹果
class abstractApple{
public:
    virtual void showName()=0;
};
//中国苹果
class chinaApple:public abstractApple{
public:
    virtual void showName()
    {
        cout<<"china apple"<<endl;
    }
};
//美国苹果
class usaApple:public abstractApple{
public:
    virtual void showName()
    {
        cout<<"usa apple"<<endl;
    }
};
//日本苹果
class japanApple:public abstractApple{
public:
    virtual void showName()
    {
        cout<<"japan apple"<<endl;
    }
};

//抽象梨
class abstractPear{
public:
    virtual void showName()=0;
};
//中国梨
class chinaPear:public abstractPear{
public:
    virtual void showName()
    {
        cout<<"china pear"<<endl;
    }
};
//美国梨
class usaPear:public abstractPear{
public:
    virtual void showName()
    {
        cout<<"usa pear"<<endl;
    }
};
//日本梨
class japanPear:public abstractPear{
public:
    virtual void showName()
    {
        cout<<"japan pear"<<endl;
    }
};

//抽象香蕉
class abstractBanana{
public:
    virtual void showName()=0;
};
//中国香蕉
class chinaBanana:public abstractBanana{
public:
    virtual void showName()
    {
        cout<<"china Banana"<<endl;
    }
};
//美国香蕉
class usaBanana:public abstractBanana{
public:
    virtual void showName()
    {
        cout<<"usa Banana"<<endl;
    }
};
//日本香蕉
class japanBanana:public abstractBanana{
public:
    virtual void showName()
    {
        cout<<"japan Banana"<<endl;
    }
};

//抽象工厂
class abstractFactory{
public:
    virtual abstractApple* createApple()=0;
    virtual abstractPear* createPear()=0;
    virtual abstractBanana* createBanana()=0;
};

//中国工厂
class chinaFactory:public abstractFactory{
public:
    virtual abstractApple* createApple(){
        return new chinaApple;
    }
    virtual abstractPear* createPear(){
        return new chinaPear;
    }
    virtual abstractBanana* createBanana(){
        return new chinaBanana;
    }
};

//美国工厂
class usaFactory:public abstractFactory{
public:
    virtual abstractApple* createApple(){
        return new usaApple;
    }
    virtual abstractPear* createPear(){
        return new usaPear;
    }
    virtual abstractBanana* createBanana(){
        return new usaBanana;
    }
};
//日本工厂
class japanFactory:public abstractFactory{
public:
    virtual abstractApple* createApple(){
        return new japanApple;
    }
    virtual abstractPear* createPear(){
        return new japanPear;
    }
    virtual abstractBanana* createBanana(){
        return new japanBanana;
    }
};

int main()
{
    //创建一个抽象工厂
    abstractFactory *factory=NULL;
    //创建一个抽象苹果
    abstractApple* apple=NULL;    
    //创建一个抽象梨
    abstractPear* pear=NULL;
    //创建一个抽象香蕉    
    abstractBanana* banana=NULL;
    
    
    //创建一个中国苹果
    factory=new chinaFactory;
    apple=factory->createApple();
    apple->showName();
    //创建一个中国香蕉
    banana=factory->createBanana();
    banana->showName();
    //创建一个中国梨
    pear=factory->createPear();
    pear->showName();
    delete apple;
    delete pear;
    delete banana;
    delete factory;
    
    //创建一个日本苹果
    factory=new japanFactory;
    apple=factory->createApple();
    apple->showName();
    //创建一个日本香蕉
    banana=factory->createBanana();
    banana->showName();
    //创建一个日本梨
    pear=factory->createPear();
    pear->showName();
    delete apple;
    delete pear;
    delete banana;
    delete factory;
    
    
    
    return 0;
}