《抽象工厂模式》

最新推荐文章于 2024-04-13 16:38:06 发布

wzj_05

最新推荐文章于 2024-04-13 16:38:06 发布

阅读量413

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

15 篇文章 0 订阅

订阅专栏

抽象工厂模式，就是把工厂类也给他多态了。

根据需求不同的工厂生产不同品种的实体。比如在游戏中。纯在vip用户对应的vip的宠物对应的vip的怪物，或者vip任务。因此，vip工厂就生产vip这些东西了。但是普通的也要生产。因此就抽象出来两个类了。

下面我是根据游戏中，不同的角色来定义的一些实体类。直接上图，大家就看明白了

也就是特殊对象特殊对待。因此工厂就要特殊了。也就是要把工厂类抽象出来一个。

下面就上打码了，代码量比较大。。不过自己很快就实现了。

[cpp]view plaincopy 
   
 /************************************************************************/    
 /* @filename    abstractFactory.cpp  
    04.   @author       wallwind  
    05.   @createtime    2012/10/21 00:40 
    06.   @function      抽象工厂模式  
    07.   @email       wochenglin@qq.com  
    08.*/    
    /************************************************************************/    
   
   
 #include "stdafx.h"  
 #include <iostream>  
   
 using namespace std;  
   
 //用户类  
 class User  
 {  
 public:  
      User (){}  
     virtual ~User (){}  
   
     virtual void attack() = 0;  
   
     virtual void defense() = 0;  
   
 };  
 //怪物类  
 class Monster  
 {  
 public:  
      Monster (){}  
     virtual ~Monster (){}  
   
     virtual void attack() = 0;  
   
     virtual void defense() = 0;  
   
 };  
 //宠物类  
 class Pet  
 {  
 public:  
      Pet (){}  
     virtual ~Pet (){}  
   
     virtual void attack() = 0;  
   
     virtual void defense() = 0;  
   
 };  
   
   
 //游戏中还有很多角色。比如刀客，异人等  
   
 class SwordUser:public User  
 {  
 public:  
   
     SwordUser(){}  
     ~SwordUser(){}  
   
     void attack()  
     {  
         cout<<"SwordUser:attack"<<endl;  
     }  
       
     void defense()  
     {  
         cout<<"SwordUser:defense"<<endl;  
     }  
   
 };  
   
 class SpecialUser:public User  
 {  
 public:  
   
     SpecialUser(){}  
     ~SpecialUser(){}  
   
     void attack()  
     {  
         cout<<"SpecialUser:attack"<<endl;  
     }  
   
     void defense()  
     {  
         cout<<"SpecialUser:defense"<<endl;  
     }  
   
 };  
 //怪物氛围一般的怪物，和BOSS类。  
   
 class GeneralMonster:public Monster  
 {  
 public:  
   
     GeneralMonster(){}  
     ~GeneralMonster(){}  
   
     void attack()  
     {  
         cout<<"GeneralMonster:attack"<<endl;  
     }  
   
     void defense()  
     {  
         cout<<"GeneralMonster:defense"<<endl;  
     }  
   
 };  
   
 class BossMonster:public Monster  
 {  
 public:  
   
     BossMonster(){}  
     ~BossMonster(){}  
   
     void attack()  
     {  
         cout<<"BossMonster:attack"<<endl;  
     }  
   
     void defense()  
     {  
         cout<<"BossMonster:defense"<<endl;  
     }  
   
 };  
   
 宠物很多种，比如用来进攻的。还有用来骑得等等  
 class AttackPet:public Pet  
 {  
 public:  
   
     AttackPet(){}  
     ~AttackPet(){}  
   
     void attack()  
     {  
         cout<<"AttackPet:attack"<<endl;  
     }  
   
     void defense()  
     {  
         cout<<"AttackPet:defense"<<endl;  
     }  
   
 };  
   
 class GeneralPet:public Pet  
 {  
 public:  
   
     GeneralPet(){}  
     ~GeneralPet(){}  
   
     void attack()  
     {  
         cout<<"GeneralPet:attack"<<endl;  
     }  
   
     void defense()  
     {  
         cout<<"GeneralPet:defense"<<endl;  
     }  
   
 };  
   
 抽象工厂类  
   
 class AbstractFactory  
 {  
 public:  
     AbstractFactory(){}  
     virtual ~AbstractFactory(){}  
   
     virtual User * createUser() = 0;  
     virtual Monster* createMonster() = 0;  
     virtual Pet* createPet() = 0;  
 };  
   
 class SpecialFactory: public AbstractFactory  
 {  
     public :  
         SpecialFactory(){}  
         ~SpecialFactory(){}  
     User* createUser()  
     {  
         User *retUser;  
         retUser = new SwordUser();  
         return retUser;  
     }  
   
     Monster* createMonster()  
     {  
         Monster* retMonster;  
         retMonster = new BossMonster();  
         return retMonster;  
   
     }  
   
     Pet* createPet()  
     {  
         Pet* retPet;  
         retPet = new AttackPet();  
         return retPet;  
     }  
       
 };  
   
   
 class GeneralFactory: public AbstractFactory  
 {  
 public :  
     GeneralFactory(){}  
     ~GeneralFactory(){}  
     User* createUser()  
     {  
         User *retUser;  
         retUser = new SpecialUser();  
         return retUser;  
     }  
   
     Monster* createMonster()  
     {  
         Monster* retMonster;  
         retMonster = new GeneralMonster();  
         return retMonster;  
   
     }  
   
     Pet* createPet()  
     {  
         Pet* retPet;  
         retPet = new GeneralPet();  
         return retPet;  
     }  
   
 };  
   
 class  RoleCreate  
 {  
 public:  
     RoleCreate(AbstractFactory* af):m_role(af){}  
     ~RoleCreate()  
     {  
         if (m_role!=NULL)  
         {  
             delete m_role;  
         }  
     }  
     void factory()  
     {  
         m_role->createUser()->attack();  
         m_role->createMonster()->attack();  
         m_role->createPet()->attack();  
     }  
 private:  
     AbstractFactory* m_role;  
       
 };  
 int _tmain(int argc, _TCHAR* argv[])  
 {  
       
     AbstractFactory* factory;  
   
         factory= new SpecialFactory();  
     RoleCreate role(factory);  
     role.factory();  
   
     factory = new GeneralFactory();  
     RoleCreate role1(factory);  
     role1.factory();  
   
     if (factory!=NULL)  
     {  
         delete factory;  
         factory =NULL;  
     }  
     return 0;  
 }  

wzj_05

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《抽象工厂模式》

抽象工厂模式，就是把工厂类也给他多态了。根据需求不同的工厂生产不同品种的实体。比如在游戏中。纯在vip用户对应的vip的宠物对应的vip的怪物，或者vip任务。因此，vip工厂就生产vip这些东西了。但是普通的也要生产。因此就抽象出来两个类了。下面我是根据游戏中，不同的角色来定义的一些实体类。直接上图，大家就看明白了也就是
复制链接

扫一扫

专栏目录