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

转载 2015年07月09日 20:23:21

简单工厂:

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

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


工厂方法:

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

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

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


抽象工厂类:

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

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

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

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


实例代码,用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();
}




设计模式-2-抽象工厂方法

一、概述 1-抽象工厂 提供一个接口,用于创建相关或者依赖对象的家族,而不需要指定具体的实现类 2-设计原则 (1)开闭(2)多用组合,少继承 抽象工厂和工厂方法的区别 (1)工厂通过继承解耦;抽象...

java设计模式——抽象工厂方法

说明:什么使用我们可以使用抽象工厂方法?怎么使用抽象工厂方法 应用场景:当我们建立的两个类之间有组合关系的时候,比如说学校、老师、学生。这那个之间的关系是:学校可以使一中、二中、三中。老师可...

设计模式-抽象工厂方法

设计模式-抽象工厂方法

设计模式:简单工厂、工厂方法、抽象工厂之小结与区别

简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性。本文是本人对这三种模式学习后的一个小结以及对他们...

设计模式:简单工厂、工厂方法、抽象工厂之小结与区别 (转)

设计模式:简单工厂、工厂方法、抽象工厂之小结与区别 (转) 简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并...
  • nysyxxg
  • nysyxxg
  • 2013年04月16日 17:41
  • 593

Java 设计模式中,简单工厂、工厂方法、抽象工厂的区别

简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性。 简单工厂 简单工厂模式的工厂类一般是使用...

设计模式:简单工厂、工厂方法、抽象工厂之小结与区别

简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性。 本文是本人对这三种模式学习后的一个小结以...

设计模式:简单工厂、工厂方法、抽象工厂之小结与区别

简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性。 本文是本人对这三种模式学习后的一个小结以及对...

设计模式:简单工厂、工厂方法、抽象工厂之小结与区别 .

简单工厂,工厂方法,抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来,优化了系统的架构,并且增强了系统的扩展性。 本文是本人对这三种模式学习后的一个小结以及对...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:简单工厂,工厂方法,抽象工厂 三种设计模式的区别和实例
举报原因:
原因补充:

(最多只允许输入30个字)