设计模式在cocos2d-x中的使用--简单工厂模式(Simple Factory)

什么是简单工厂模式？

从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

简单工厂模式在cocos2d-x中怎么用，我们通过下面的小例子来了解一下。

假如我们在开发一款类似魔兽的RPG游戏，在游戏中会出现很多种族的角色，如：人族、兽族。

这些种族一般都会定义为一个类，如果兽族Orc类，人族Human类。

兽族、人族两个类都同样属于种族，那么我们可以给他们定义一个共同的父类， 名字叫种族Race类。

既然是种族，肯定有种族的名字，还有长什么样子，我们想把名字和样子显示在屏幕上显示出来，那么我们在父类Race中定义两个属性，一个名字name， 一个形象features。

//
//  Race.h
//  DesignPattern_Factory
//
//  Created by cc on 14-6-28.
//
//

#ifndef __DesignPattern_Factory__Race__
#define __DesignPattern_Factory__Race__

using namespace std;

#include "cocos2d.h"
#include "IRaceConst.h"
#include <string>

class Race : public cocos2d::CCSprite {

protected:

	//种族名字
	std::string m_name;

	//种族形象(用图片表示)
	std::string m_features;

public:

#pragma mark  <getters && setter>
//
// 	std::string Name() const { return m_name; }
// 	void Name(std::string val) { m_name = val; }
//
// 	std::string Features() const { return m_features; }
// 	void Features(std::string val) { m_features = val; }

#pragma mark  <构造 && 析构>

    /**
     *	@brief	构造
     *
     */
    Race();

    /**
     *	@brief	析构
     *
     */
    virtual ~Race();

};

#endif /* defined(__DesignPattern_Factory__Race__) */

父类“种族类”写好了，我们就可以实现人族，兽族和亡灵族三个子类了。

兽族类：

//
//  Orc.h
//  DesignPattern_Factory
//
//  Created by cc on 14-6-28.
//
//

#ifndef __DesignPattern_Factory__Orc__
#define __DesignPattern_Factory__Orc__

#include "Race.h"

class Orc : public Race {

public:

#pragma mark  <构造 && 析构>

    /**
     *	@brief	构造
     *
     */
    Orc();

    /**
     *	@brief	析构
     *
     */
    virtual ~Orc();

#pragma mark  <创建 && 初始化>

    /**
     *	@brief	创建兽族
     *
     *	@return	兽族
     */
    static Orc* create();

    /**
     *	@brief	初始化兽族
     *
     *	@return	true: 初始化成功 false: 初始化失败
     */
    bool init();

};

#endif /* defined(__DesignPattern_Factory__Orc__) */

<pre name="code" class="cpp">//
//  Orc.cpp
//  DesignPattern_Factory
//
//  Created by cc on 14-6-28.
//
//

#include "Orc.h"

#pragma mark  <构造 && 析构>

/**
 *	@brief	构造
 *
 */
Orc::~Orc() {

}

/**
 *	@brief	析构
 *
 */
Orc::Orc() {

}

#pragma mark  <创建 && 初始化>

/**
 *	@brief	创建兽族
 *
 *	@return	兽族
 */
Orc* Orc::create() {

    Orc *pRet = new Orc();
    if (pRet && pRet->init()) {
        pRet->autorelease();
        return pRet;
    }

    CC_SAFE_DELETE(pRet);
    return NULL;

}

/**
 *	@brief	初始化兽族
 *
 *	@return	true: 初始化成功 false: 初始化失败
 */
bool Orc::init(){

	this->m_features = "orc.png";
	this->m_name = "兽族";

    if (initWithFile(this->m_features.c_str())) {

		CCLabelTTF* pLabName = CCLabelTTF::create(this->m_name.c_str(), "Marker Felt", 22.0f);
		pLabName->setPosition(ccp(this->getContentSize().width / 2, this->getContentSize().height + 30.0f));
		this->addChild(pLabName, 1);

        return true;
    }

    return false;
}


人族类：


//
//  Human.h
//  DesignPattern_Factory
//
//  Created by cc on 14-6-28.
//
//

#ifndef __DesignPattern_Factory__Human__
#define __DesignPattern_Factory__Human__

#include "Race.h"

USING_NS_CC;

class Human : public Race {

public:

#pragma mark  <构造 && 析构>

    /**
     *	@brief	构造
     *
     */
    Human();

    /**
     *	@brief	析构
     *
     */
    virtual ~Human();

#pragma mark  <创建 && 初始化>

    /**
     *	@brief	创建人族
     *
     *	@return	人族
     */
    static Human* create();

    /**
     *	@brief	初始化人族
     *
     *	@return	true: 初始化成功 false: 初始化失败
     */
    bool init();

};

#endif /* defined(__DesignPattern_Factory__Race__) */


//
//  Human.cpp
//  DesignPattern_Factory
//
//  Created by cc on 14-6-28.
//
//

#include "Human.h"

#pragma mark  <构造 && 析构>

/**
 *	@brief	构造
 *
 */
Human::~Human() {

}

/**
 *	@brief	析构
 *
 */
Human::Human(){

}

#pragma mark  <创建 && 初始化>

/**
 *	@brief	创建人族
 *
 *	@return	人族
 */
Human* Human::create() {

    Human *pRet = new Human();
    if (pRet && pRet->init()) {
        pRet->autorelease();
        return pRet;
    }

    CC_SAFE_DELETE(pRet);
    return NULL;

}

/**
 *	@brief	初始化人族
 *
 *	@return	true: 初始化成功 false: 初始化失败
 */
bool Human::init(){

	this->m_name = "人族";
	this->m_features = "hum.png";

    if (initWithFile(this->m_features.c_str())) {

		CCLabelTTF* pLabName = CCLabelTTF::create(this->m_name.c_str(), "Marker Felt", 22.0f);
		pLabName->setPosition(ccp(this->getContentSize().width / 2, this->getContentSize().height + 30.0f));
		this->addChild(pLabName, 1);

        return true;
    }

    return false;
}



好了~~~ 兽族和人类两个类写完了，我们想要在兽族和人族这两个子类中分别显示出自己种族的名字，和图片，既然这两个类都属于种族类，那么我们就可以由Race类来统一的管理和创建这两个类的实例，假如我们想创建人族Human类的对象时，只需告诉Race类，我要创建人族类的对象就行了，这时候Race类就是一个对象的生产工厂，只要是他的子类，都有他来统一创建，是不是很方便，看一下下面一段代码。


//
//  IRaceConst.h
//  DesignPattern_Factory
//
//  Created by ChengChao on 14-6-28.
//
//

#ifndef __DesignPattern_Factory__IRaceConst__
#define __DesignPattern_Factory__IRaceConst__

/**
 *	@brief	保存种族常量的接口
 */
class IRaceConst {

public:

    //种族类型
    enum RaceType {
        eRaceTypeNone,
        eRaceTypeHuman,     //人族
        eRaceTypeOrc,       //兽人
		eRaceTypeUd,		//亡灵
		eRaceTypeNe			//精灵
	};

};

#endif /* defined(__DesignPattern_Factory__IRaceConst__) */


/**
 *	@brief	创建种族
 *
 *	@return	种族
 */
Race* Race::createRaceByType(int aRaceType) {

    Race* pRace = NULL;

    switch (aRaceType) {
        case IRaceConst::eRaceTypeHuman:
            //人族
            pRace = Human::create();
            break;
        case IRaceConst::eRaceTypeOrc:
            //兽族
            pRace = Orc::create();
			break;
		case IRaceConst::eRaceTypeUd:
			//亡灵族
			pRace = Ud::create();
			break;
        default:
            break;
    }

    return pRace;
}



这个方法是Race类的一个静态static 工厂方法，通过传入种族的枚举类型，统一由Race类来创建子类的对象，我们想要一个人族，就传一个人族类型，想要一个兽族，就传一个兽族类型，我们把人族和兽族添加到场景里去，我们来看看运行效果。


HelloWorldScene中：


	Race* pHumanRace = Race::createRaceByType(IRaceConst::eRaceTypeHuman);
	pHumanRace->setPosition(ccp(100, 100));
	this->addChild(pHumanRace, 1);

	Race* pOrcRace = Race::createRaceByType(IRaceConst::eRaceTypeOrc);
	pOrcRace->setPosition(ccp(400, 100));
	this->addChild(pOrcRace, 1);


运行效果如下：




如果我们现在又有了一个新的需求，加了一个亡灵族呢？ 只需要再创建一个亡灵族类继承种族类Race，然后给亡灵类指定一个类型加到保存种族常量的接口IRaceConst里去，再通过静态工厂方法Race::createRaceByType()创建亡灵类的实例来，把亡灵加到场景里就行了，把代码贴出来，大家可以自己试试~


最后附上源码： http://download.csdn.net/detail/oktears/7568355


本文由CC原创总结，如需转载请注明出处：http://blog.csdn.net/oktears/article/details/35780455


设计模式在cocos2d-x中的使用--简单工厂模式(Simple Factory)
				


				
时间： 2024-10-09 21:17:31 

		


		


	

	
	

		


		
设计模式在cocos2d-x中的使用--简单工厂模式(Simple Factory)的相关文章


								

		

			

                设计模式之简单工厂模式Simple Factory（四创建型）
			

		

		

									

				工厂模式简介. 工厂模式专门负责将大量有共同接口的类实例化 工厂模式可以动态决定将哪一个类实例化,不必事先知道每次要实例化哪一个类. 工厂模式有三种形态: 1.简单工厂模式Simple Factory,又称静态工厂方法模式 2.工厂方法模式Factory Method,又称多态性工厂模式 3.抽象工厂模式Abstract Factory,又称工具箱模式 2.什么是简单工厂模式 简单工厂模式是类的创建模式.是由一个工厂对象决定创建出哪一种产品类的实例,是不同的工厂方法模式的一个特殊实现.由一个工厂			

		

	

				

		

			

                简单工厂模式( Simple Factory Pattern )
			

		

		

									

				1. 简单工厂模式( Simple Factory Pattern ) 1.1. 模式动机 考虑一个简单的软件应用场景,一个软件系统可以提供多个外观不同的按钮(如圆形按钮.矩形按钮.菱形按钮等), 这些按钮都源自同一个基类,不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的外观,如果我们希望在使用这些按钮时,不需要知道这些具体按钮类的名字,只需要知道表示该按钮类的一个参数,并提供一个调用方便的方法,把该参数传入方法即可返回一个相应的按钮对象,此时,就可以使用简单工厂模式. 1.2			

		

	

				

		

			

                大白话简单工厂模式 (Simple Factory Pattern)
			

		

		

									

				大白话简单工厂模式 (Simple Factory Pattern) 从买车经历说起 毕业两年,码农张小两口无法忍受挤公交,凌晨起床抢火车票的痛苦,遂计划买车.逛了多家4S店,最终定下日产某车型的轿车.4S店接受订单后,向工厂说明车型,工厂随后进行汽车制造,运输到4S店中再到了小两口的手上,小两口终于成了有车一族. 仔细分析,4S销售模式即为典型的简单工厂模式.下面从代码的角度进行分析. 无工厂模式 首先,我们先分析4S店最初的模式(企业个人作坊阶段,无工厂).4S店卖车首先要有车,这里只取日产			

		

	

				

		

			

                Net设计模式实例之简单工厂模式(Simple Factory Pattern)
			

		

		

									

				一.简单工厂模式简介(Bref Introduction) 简单工厂模式(Simple Factory Pattern)的优点是,工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖 二.解决的问题(What To Solve) 客户实例化对象时不需要关心该对象是由哪个子类实例化的. 三.简单工厂模式分析(Analysis) 1.简单工厂模式结构 IProduct接口:抽象产品类 ConcreteProduct类:产品类的具体实现 Simp			

		

	

				

		

			

                Headfirst设计模式的C++实现——简单工厂模式(Simple Factory)之二
			

		

		

									

				为了引出后续的工厂方法,把在简单工厂模式的基础上增加了新功能——加盟店 简而言之就是把原来的单一简单工厂(能生产cheese和greek两种pizza)细分成了纽约地区的和芝加哥地区的(每种地区都能生产cheese和greek两种pizza) 和之前的简单工厂相比,PizzaStore中的PizzaFactory由构造时传入一个引用,从SimplePizzaFactory中派生出两个类,原来的cheese和greek Pizza也根据地区做了扩展. Pizza.h 1 #ifndef _PIZZ			

		

	

				

		

			

                简单工厂模式(simple factory )
			

		

		

									

				简单工厂模式的构成工厂类   (Creator)角色:担任这个角色的是简单工厂模式的核心,含有与应用紧密相关的商业逻辑.工厂类在客户端的直接调用下创建产品对象,它往往由一个具体类实现.抽象产品(Product)角色:担任这个角色的类是简单工厂模式所创建的对象的父类,或它们共同拥有的接口.抽象产品角色可以用一个接口或者抽象类实现.具体产品(Concrete Product)角色:简单工厂模式所创建的任何对象都是这个角色的实例,具体产品角色由一个具体类实现. 1 /*工厂类 (Creator)角色*			

		

	

				

		

			

                2.简单工厂模式(Simple Factory)
			

		

		

									

				using System; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { //如果我们需要加入什么类型的食物,添加子类就可以 FoodFactory _foodfactory = new FoodFactory(); Food _food = _foodfactory.CreateFood(2); _food.MakeFood(); } } /// <summary> ///			

		

	

				

		

			

                研磨设计模式解析及python代码实现——(一)简单工厂模式
			

		

		

									

				最近在学设计模式,正巧书之前学了些python,但用的还不是很成熟.<研磨设计模式>书上只给了java代码,本着以练手为目标,我照着书上打了一遍java代码,在仔细体会其思想后,将其写成了python的代码.有不对的地方希望各位批评指正~ 具体原理不多做介绍,具体可以参考http://chjavach.iteye.com的博客,或者<研磨设计模式>的书. 一.背景介绍 接口思想: 众所周知,面向对象语言最大的特点便是封装,继承,多态这三个概念.而像Java等面向对象语言最核心的思想			

		

	

				

		

			

                设计模式的征途—2.简单工厂（Simple Factory）模式
			

		

		

									

				工厂模式是最常用的一种创建型模式,通常所说的工厂模式一般是指工厂方法模式.本篇是是工厂方法模式的“小弟”,我们可以将其理解为工厂方法模式的预备知识,它不属于GoF 23种设计模式,但在软件开发中却也应用地比较频繁.此外,工厂方法模式还有一位“大哥”—抽象工厂模式,会在后面进行介绍. 简单工厂模式(Singleton) 学习难度:★★☆☆☆ 使用频率:★★★☆☆ 一.从一个图表库谈起 M公司想要基于C#语言开发一套图表库,该图表库可以为应用系统提供各种不同外观的图标,例如柱状图.饼状图或折线图等.