关闭

简单工厂,工厂方法,抽象工厂 三种设计模式的区别和实例

标签: 简单工厂工厂方法抽象工厂设计模式
131人阅读 评论(0) 收藏 举报
分类:

简单工厂:

一个产品抽象类,可以派生很多具体产品类。

一个具体工厂类,可以创建多种具体的产品实例。


工厂方法:

一个抽象产品类,可以派生很多具体产品类。

一个抽象工厂类,可以派生很多具体工厂类。

每一个具体工厂可以创建多种具体的产品实例


抽象工厂类:

一个抽象产品类,可以派生很多产品基类。

每一个产品基类可以派生很多具体产品类

一个抽象工厂类,可以派生很多具体工厂类。

每一个具体工厂类可以创建多种具体的产品实例。


实例代码,用QT实现

#include <QtCore/QCoreApplication>
#include <QDebug>
class product
{
  protected:
    product(void)
    {
      qDebug()<<"construct product";
    }
  public:
    virtual ~product(void)
    {
       qDebug()<<"destroy product";
    }
  public:
    virtual void Function()=0;
};


class CreateProductA:public product
{
  public:
    CreateProductA(void)
    {
       qDebug()<<"construct CreateProductA";
    }
 public:
    virtual ~CreateProductA(void)
   {
      qDebug()<<"destroy CreateProductA";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductA Function";
    }
};


class CreateProductA1:public CreateProductA
{
  public:
    CreateProductA1(void)
    {
       qDebug()<<"construct CreateProductA1";
    }
 public:
    virtual ~CreateProductA1(void)
   {
      qDebug()<<"destroy CreateProductA1";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductA Function";
    }
};




class CreateProductB:public product
{
  public:
    CreateProductB(void)
    {
       qDebug()<<"construct CreateProductB";
    }
 public:
    virtual ~CreateProductB(void)
   {
      qDebug()<<"destroy CreateProductB";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductB Function";
    }
};


class CreateProductB1:public CreateProductB
{
  public:
    CreateProductB1(void)
    {
       qDebug()<<"construct CreateProductB1";
    }
 public:
    virtual ~CreateProductB1(void)
   {
      qDebug()<<"destroy CreateProductB1";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductB Function";
    }
};


class SimplyFactory
{
  public:
    SimplyFactory(){}
    ~SimplyFactory(){}
  public:
    product *createProduct(int productType)
    {
       product *p = 0;
       switch(productType)
       {
         case 0:
           p= new CreateProductA();
         break;
       case 1:
         p= new CreateProductB();
       break;
       default:
         p= new CreateProductA();
       break;
       }
       return p;
    }
    product *CreateProA()
    {
        return new CreateProductA();
    }
    product *CreateProB()
    {


       return new CreateProductB();


    }
};


class FactoryWay
{
   public:
    FactoryWay(void)
    {
       qDebug()<<"construct FactoryWay";
    }
    virtual ~FactoryWay(void)
    {
      qDebug()<<"destroy FactoryWay";
    }
    virtual product* CreatePro(int ProductType=0)=0;
};


class CreateFactory1:public FactoryWay
{
  public:
    CreateFactory1()
    {
        qDebug()<<"construct CreateFactory1";
    }
    ~CreateFactory1()
    {
       qDebug()<<"Destory CreateFactory1";
    }
    product* CreatePro(int ProductType)
    {
       product *p =0;
       switch(ProductType)
       {
         case 0:
           p= new CreateProductA();
           break;
        case 1:
         p= new CreateProductB();
         break;
       default:
         p= new CreateProductA();
         break;
       }
       return p;
    }
};




class CreateFactory2:public FactoryWay
{
  public:
    CreateFactory2()
    {
        qDebug()<<"construct CreateFactory2";
    }
    ~CreateFactory2()
    {
       qDebug()<<"Destory CreateFactory2";
    }
    product* CreatePro(int ProductType)
    {
       product *p =0;
       switch(ProductType)
       {
         case 0:
           p= new CreateProductA();
           break;
        case 1:
         p=  new CreateProductB();
         break;
       default:
         p=  new CreateProductA();
         break;
       }
       return p;
    }
};




class AbstractFactory
{
  public:
    AbstractFactory()
    {
        qDebug()<<"construct AbstractFactory";
    }
    virtual ~AbstractFactory()
    {
      qDebug()<<"destroy AbstractFactory";
    }
  public:
    virtual CreateProductA* CreatA() =0;
    virtual CreateProductB* CreatB() =0;
};


class CreateAbstractFactory1:public AbstractFactory
{
  public:
    CreateAbstractFactory1()
    {
        qDebug()<<"construct CreateAbstractFactory1";
    }
    virtual ~CreateAbstractFactory1()
    {
      qDebug()<<"destroy CreateAbstractFactory1";
    }
  public:
    virtual CreateProductA* CreatA()
    {
        CreateProductA *q;
        q= new CreateProductA1();
        return q ;
    }
    virtual CreateProductB* CreatB()
    {
        CreateProductB *p;
        p= new CreateProductB1();
        return p ;


    }
};


class CreateAbstractFactory2:public AbstractFactory
{
  public:
    CreateAbstractFactory2()
    {
        qDebug()<<"construct CreateAbstractFactory2";
    }
    virtual ~CreateAbstractFactory2()
    {
      qDebug()<<"destroy CreateAbstractFactory2";
    }
  public:
    virtual CreateProductA* CreatA()
    {
        CreateProductA *p;
        p= new CreateProductA1();
        return p ;
    }
    virtual CreateProductB* CreatB()
    {
        CreateProductB *p;
        p= new CreateProductB1();
        return p ;


    }
};


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

//简单工厂
    SimplyFactory sf;
   product *p1 = sf.CreateProA();
    p1->Function();
    delete p;
    p1= sf.CreateProB();
   p1->Function();
    delete p1;

//工厂方法
    FactoryWay *fct = new CreateFactory1();
    product *p2 = fct->CreatePro(0);
   p2->Function();
    delete p2;
    p2= fct->CreatePro(2);
    p2->Function();
    delete p2;
    fct = new CreateFactory2();
    p2= fct->CreatePro();
    delete p2;
    delete fct;

//抽象工厂
    AbstractFactory *absfct = new CreateAbstractFactory1();
    CreateProductA *cpa = absfct->CreatA();
    cpa->Function();
    delete cpa;
    CreateProductB *cpb = absfct->CreatB();
    cpb->Function();
    delete cpb;
    delete absfct;
    absfct = new CreateAbstractFactory2();
    cpa = absfct->CreatA();
    delete cpa;
    cpb = absfct->CreatB();
    cpb->Function();
    delete cpb;

    return a.exec();
}




0
0

猜你在找
【直播】机器学习&数据挖掘7周实训--韦玮
【套餐】系统集成项目管理工程师顺利通关--徐朋
【直播】3小时掌握Docker最佳实战-徐西宁
【套餐】机器学习系列套餐(算法+实战)--唐宇迪
【直播】计算机视觉原理及实战--屈教授
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之矩阵--黄博士
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之凸优化--马博士
【套餐】Javascript 设计模式实战--曾亮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:3165次
    • 积分:62
    • 等级:
    • 排名:千里之外
    • 原创:2篇
    • 转载:7篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档