3.抽象工厂模式

1抽象工厂模式的核心内容是：

A:消费者分离，分别用不同的类实现（包含抽象类和实现类）

B:操作分离，分别用不同的类实现（包含抽象类和实现类）

C:使用工厂类使消费者类和操作类关联起来，有总线的功能。

2抽象工厂模式的作用：使用工厂将分别独立的消费者和实际的操作关联起来。

3抽象工厂模式具体描述

工厂模式：客户类和工厂类分开。

消费者任何时候需要某种产品，只需向工厂请求即可。

 

消费者无须修改就可以接纳新产品。缺点是当产品修改时，

 

工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

 

追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，

虽然口味有所不同，但不管你带MM去麦当劳或肯德基，

只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory。

 

消费者不固定，工厂者不固定，（工厂根据消费者动作）

 

实现消费者抽象基类，消费者派生类的实现，实例化就是消费者

 

操作的抽象基类，实现派生类各种操作，实例化的操作

 

工厂的抽象类，抽象类包含了两个抽象类的接口（消费者，操作）

抽象类实现了工厂类的抽象，实例化的派生类，实现工厂，

根据用户设置用户，根据操作设置操作

4.策略模式类图

5.代码：

#include<iostream>

#include<string>

 

usingnamespacestd;

 

//工厂模式：客户类和工厂类分开。

//消费者任何时候需要某种产品，只需向工厂请求即可。

 

//消费者无须修改就可以接纳新产品。缺点是当产品修改时，

 

//工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

//

//追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，

//虽然口味有所不同，但不管你带MM去麦当劳或肯德基，

//只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory。

 

//消费者不固定，工厂者不固定，（工厂根据消费者动作）

 

//实现消费者抽象基类，消费者派生类的实现，实例化就是消费者

 

//操作的抽象基类，实现派生类各种操作，实例化的操作

 

//工厂的抽象类，抽象类包含了两个抽象类的接口（消费者，操作）

//抽象类实现了工厂类的抽象，实例化的派生类，实现工厂，

//根据用户设置用户，根据操作设置操作

 

classIUser

{

public:

   //纯虚接口类，抽象类

   virtualvoidgetUser() = 0;

   virtualvoidsetUser() = 0;

};

 

//继承抽象实现sql数据库使用者的实例化

classSqlUser :publicIUser

{

public:

   voidgetUser()

   {

       cout <<"在sql中返回user" << endl;

   }

   voidsetUser()

   {

       cout <<"在sql中设置user" << endl;

   }

};

 

//继承抽象实现access数据使用者的实例化

classAccessUser :publicIUser

{

public:

   voidgetUser()

   {

       cout <<"在Access中返回user" << endl;

   }

   voidsetUser()

   {

       cout <<"在Access中设置user" << endl;

   }

};

 

//抽象类，提供接口

classIDepartment

{

public:

   virtualvoidgetDepartment() = 0;

   virtualvoidsetDepartment() = 0;

};

 

//SQL操作的实现

classSqlDepartment :publicIDepartment

{

public:

   voidgetDepartment()

   {

       cout <<"在sql中返回Department" << endl;

   }

   voidsetDepartment()

   {

       cout <<"在sql中设置Department" << endl;

   }

};

 

//access操作的实现

classAccessDepartment :publicIDepartment

{

public:

   voidgetDepartment()

   {

       cout <<"在Access中返回Department" << endl;

   }

   voidsetDepartment()

   {

       cout <<"在Access中设置Department" << endl;

   }

};

 

//抽象工厂

classIFactory

{

public:

   virtualIUser *createUser() = 0;

   virtualIDepartment *createDepartment() = 0;

};

 

//抽象工厂一个实现

classSqlFactory :publicIFactory

{

public:

   IUser *createUser()

   {

       returnnewSqlUser();

   }

   IDepartment *createDepartment()

   {

       returnnewSqlDepartment();

   }

};

 

//抽象工厂一个实现

classAccessFactory :publicIFactory

{

public:

   IUser *createUser()

   {

       returnnewAccessUser();

   }

   IDepartment *createDepartment()

   {

       returnnewAccessDepartment();

   }

};

 

//变相的实现了静态类

classDataAccess

{

private:

   staticstringdb;

   //string db="access";

public:

   staticIUser *createUser()

   {

       if (db == "access")

       {

           returnnewAccessUser();

       }

       elseif (db == "sql")

       {

           returnnewSqlUser();

       }

   }

   staticIDepartment *createDepartment()

   {

       if (db == "access")

       {

           returnnewAccessDepartment();

       }

       elseif (db == "sql")

       {

           returnnewSqlDepartment();

       }

   }

};

stringDataAccess::db = "sql";

 

intmain()

{

   //IFactory *factory=new SqlFactory();

   IFactory *factory;//抽象工厂

   IUser *user;//抽象消费者

   IDepartment *department;//提供的操作

 

   factory =newAccessFactory();//基类的指针指指向派生类的对象

   user =factory->createUser();//基类的指针指向派生类的对象

   department =factory->createDepartment();//基类的指针指向派生类的对象

 

   user->getUser();

   user->setUser();//访问acesss接口

 

   department->getDepartment();

   department->setDepartment();//接口

 

   cout <<"--------------------" <<endl;

 

   user =DataAccess::createUser();

   department =DataAccess::createDepartment();

 

   user->getUser();

   user->setUser();

   department->getDepartment();

   department->setDepartment();

 

   cin.get();

   return 0;

}

运行结果如下：