抽象工厂模式

#include <QCoreApplication>
#include <QDebug>

///  抽象产品球类
class AbstractBall
{
public:
    virtual~AbstractBall();
    
    //抽象方法
    virtual void play() = 0;
};

AbstractBall::~AbstractBall()
{

}

///  具体产品类Basketball
class Basketball : public AbstractBall
{
public:
    Basketball();
    void play() override;
};

void Basketball::play()
{
    qDebug() << "Basketball";
}

Basketball::Basketball()
{
    play();
}

///  具体产品类Football
class Football : public AbstractBall
{
public:
    Football();
    void play() override;
};

void Football::play()
{
    qDebug() << "Football";
}

Football::Football()
{
    play();
}

///  抽象产品球衣类
class AbstractShirt
{
public:
    AbstractShirt();
    virtual~AbstractShirt();
    
    //抽象方法
    virtual void play() = 0;
};

AbstractShirt::AbstractShirt()
{

}

AbstractShirt::~AbstractShirt()
{

}

///  具体产品类BasketShirt
class BasketShirt : public AbstractShirt
{
public:
    BasketShirt();
    void play() override;
};

void BasketShirt::play()
{
    qDebug() << "BasketShirt";
}

BasketShirt::BasketShirt()
{
    play();
}

///  具体产品类FootShirt
class FootShirt : public AbstractShirt
{
public:
    FootShirt();
    void play() override;
};

void FootShirt::play()
{
    qDebug() << "FootShirt";
}

FootShirt::FootShirt()
{
    play();
}


///  抽象工厂类
class AbstractFactory
{
public:
    virtual ~AbstractFactory();
    
    virtual AbstractBall *getBall() = 0;
    virtual AbstractShirt *getShirt() = 0;
};

AbstractFactory::~AbstractFactory()
{

}

/// 具体工厂类BasketballFactory
class BasketballFactory : public AbstractFactory
{
public:
    BasketballFactory();
    
    AbstractBall *getBall();
    AbstractShirt *getShirt();
};

BasketballFactory::BasketballFactory()
{
    qDebug()<< "BasketballFactory";
}

AbstractBall *BasketballFactory::getBall()
{
    return new Basketball;
}

AbstractShirt *BasketballFactory::getShirt()
{
    return new BasketShirt;
}


/// 具体工厂类FootballFactory
class FootballFactory : public AbstractFactory
{
public:
    FootballFactory();
    ~FootballFactory();
    
    AbstractBall *getBall();
    AbstractShirt *getShirt();
};

FootballFactory::FootballFactory()
{
    qDebug()<< "FootballFactory";
}

FootballFactory::~FootballFactory()
{

}

AbstractBall *FootballFactory::getBall()
{
    return new Football;
}

AbstractShirt *FootballFactory::getShirt()
{
    return new FootShirt;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    qDebug()<< "抽象工厂模式";
    
    //定义工厂类对象和产品类对象
    AbstractFactory *factory = nullptr;
    AbstractBall *ball = nullptr;
    AbstractShirt *shirt = nullptr;
    
    factory = new BasketballFactory;
    ball = factory->getBall();
    shirt = factory->getShirt();
    
    factory = new FootballFactory;
    ball = factory->getBall();
    shirt = factory->getShirt();

    return a.exec();
}