Cocos2d-x《雷电大战》(4)-策略模式实现不同子弹切换！！

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

本文从设计模式中的策略模式入手，主讲了飞机大战中英雄飞机切换不同的子弹。这里分为三种子弹。第一种:每次发一个子弹，垂直发射;第二种:每次发两个子弹，两个都是垂直发射:第三种;每次发三个子弹，两边的子弹有一定的角度，而中间的子弹垂直发射;设计模式是游戏开发经常用到的思想，建议有兴趣的同学可以好好研究下！好了，下面开始吧。

效果如下：

Cocos2d-x版本：3.4

工程环境：VS30213

一、策略模式（Stragegy Pattern）

1、简介

Strategy模式也叫策略模式是行为模式之一，它对一系列的算法加以封装，为所有算法定义一个抽象的算法接口，并通过继承该抽象算法接口对所有的算法加以封装和实现，具体的算法选择交由客户端决定（策略）。Strategy模式主要用来平滑地处理算法的切换 。

2、意图

定义一系列的算法，把它们一个个封装起来，并且它们可相互替换。使得算法可独立于使用它的客户而变化。

3、适用性

  • 如果一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
  • 一个系统需要动态的在几种算法中选择一种。那么这些算法可以包装到一个个的具体算法类里面，而这些算法类都是一个抽象算法类的子类。换言之，这些具体算法类均有统一的接口，由于多态性原则，客户端可以选择使用任何一个具体算法类，并只持有一个数据类型是抽象算法的对象。
  • 一个系统的算法使用的数据不可以让客户端知道。策略模式可以避免让客户端涉及到不必要接触到的和复杂的只与算法有关的数据。
  • 如果一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移到它们各自的Strategy类中以代替这些条件语句。

更多详细的策略模式看这里吧：24天学会设计模式------策略模式

二.子弹类与子弹管理类的代码编写

首先来看下本文的类UML图：
                               

这里的思路是把子弹发射当成是一个函数，基类子弹中定义成虚函数，然后实现类子弹中HeroBulletOne、HeroBulletTwo、HeroBulletThree分别实现不同的发射功能。然后在子弹管理类中HeroBulletLayer中有一个私有的成员变量BulletStyle *mBulletStyle.当需要切换不同的子弹时，就将new不同的HeroBulletOne或HeroBulletTwo或HeroBulletThree，赋给mBulletStyle。
下面我们来看看代码吧！！！

2.1 首先是子弹的基类：

BulletStyle.h,这里注意到virtual void shootBullet(float dt){}为虚函数，表示这里要根据的子类不同，发射不同的子弹数目；

/**
*功能 创建子弹的基类
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/
#pragma once
#ifndef __BulletStyle_H__
#define __BulletStyle_H__
#include "cocos2d.h"
USING_NS_CC;

class BulletStyle : public cocos2d::Node{
public:
	~BulletStyle();
	/**
	* 移除所有的东西
	*/
	void removeAllObject();
	/**
	*移除超出屏幕可视范围的子弹或者碰撞后的子弹清除
	*@param pNode 要删除的子弹
	*/
	void removeBullet(Node* pNode);
	/**
	*根据传入的飞机，子弹跟随发射
	*@param plane为传入飞机，可为英雄飞机或敌机
	*/
	virtual void createBullet(Node* plane);
	/**
	*发射子弹，在其中进行子弹的渲染和子弹的飞行动作，默认为单子弹
	*@param dt子弹间隔发时间
	*/
	virtual void shootBullet(float dt){}

protected:
	//子弹容器
	  Vector <Sprite *> vecBullet;
	 //批次渲染节点
	  SpriteBatchNode* bulletBatchNode;
	 //传入的飞机
	  Node* plane;
};
#endif

实现文件BulletStyle.cpp

/**
*功能 创建子弹的基类
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/

#include "BulletStyle.h"
BulletStyle::~BulletStyle(){
	//removeAllObject();
}
/**
* 移除所有的东西
*/
void BulletStyle::removeAllObject(){
	bulletBatchNode->removeAllChildren();
	vecBullet.clear();
	this->removeAllChildren();

}
/**
* 移除子弹，将子弹从容器中移除，同时也从SpriteBatchNode中移除
*/
void BulletStyle::removeBullet(Node* pNode) {
	if (NULL == pNode) {
		return;
	}
	Sprite* bullet = (Sprite*)pNode;
	bulletBatchNode->removeChild(bullet, true);
	vecBullet.eraseObject(bullet);
}
/**
*根据传入的飞机，子弹跟随发射
*@param plane为传入飞机，可为英雄飞机或敌机
*/
void BulletStyle::createBullet(Node* plane){
	this->plane = plane;
	//创建BatchNode节点
	bulletBatchNode = SpriteBatchNode::create("bullet1.png");
	this->addChild(bulletBatchNode);
	//每隔0.2S调用一次发射子弹函数
	schedule(schedule_selector(BulletStyle::shootBullet), 0.2f);//注意，这里的发射方法留给子类来实现！！！

}

2.2 只发射一个子弹的类

HeroBulletOne.h,注意，直接继承

/**
*功能 每次只发射一个子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/
#pragma once
#ifndef __HeroBulletOne_H__
#define __HeroBulletOne_H__
#include "cocos2d.h"
#include "BulletStyle.h"
USING_NS_CC;
class HeroBulletOne : public BulletStyle {
public:
	virtual  void shootBullet(float dt);
};
#endif

实现文件：

/**
*功能 每次只发射一个子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/

#include "HeroBulletOne.h"

void HeroBulletOne::shootBullet(float dt) {
		Size winSize = Director::getInstance()->getWinSize();
		auto PlanePos = plane->getPosition();
		//从缓存中创建子弹
		auto spritebullet = Sprite::createWithTexture(bulletBatchNode->getTexture());
		//将创建好的子弹添加到BatchNode中进行批次渲染
		bulletBatchNode->addChild(spritebullet);
		//将创建好的子弹添加到容器
		vecBullet.pushBack(spritebullet);

		Point bulletPos = (Point(PlanePos.x,
			PlanePos.y + plane->getContentSize().height / 2 + 20));
		spritebullet->setPosition(bulletPos);
		spritebullet->setScale(0.8f);

	    float flyVelocity = 500;//运行速度，可以自己控制，每秒所走的像素
		float flyLen = winSize.height - PlanePos.y;
		float realFlyDuration = flyLen / flyVelocity;//实际飞行的时间

		//子弹运行的距离和时间，从飞机处开始运行到屏幕顶端
		auto actionMove = MoveTo::create(realFlyDuration,
			Point(bulletPos.x, winSize.height));

		//子弹执行完动作后进行函数回调，调用移除子弹函数
		auto actionDone = CallFuncN::create(
			CC_CALLBACK_1(HeroBulletOne::removeBullet, this));

		//子弹开始跑动
		Sequence* sequence = Sequence::create(actionMove, actionDone, NULL);
		spritebullet->runAction(sequence);

	}

2.3 发射二个子弹的类

HeroBulletTwo.h,注意，直接继承

/**
*功能 每次发射二个子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/
#pragma once
#ifndef __HeroBulletTwo_H__
#define __HeroBulletTwo_H__
#include "cocos2d.h"
#include "BulletStyle.h"
USING_NS_CC;
class HeroBulletTwo : public BulletStyle {
public:
	virtual  void shootBullet(float dt);
};
#endif

实现文件：

/**
*功能 每次发射二个子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/

#include "HeroBulletTwo.h"

void HeroBulletTwo::shootBullet(float dt) {
		Size winSize = Director::getInstance()->getWinSize();
		auto PlanePos = plane->getPosition();
		//从缓存中创建子弹
		auto spritebullet1 = Sprite::createWithTexture(bulletBatchNode->getTexture());
		auto spritebullet2 = Sprite::createWithTexture(bulletBatchNode->getTexture());

		//将创建好的子弹添加到BatchNode中进行批次渲染
		bulletBatchNode->addChild(spritebullet1);
		bulletBatchNode->addChild(spritebullet2);
		//将创建好的子弹添加到容器
		vecBullet.pushBack(spritebullet1);
		vecBullet.pushBack(spritebullet2);

		Point bulletPos1 = (Point(PlanePos.x - plane->getContentSize().width / 4,
			PlanePos.y + plane->getContentSize().height / 2+10 ));

		Point bulletPos2 = (Point(PlanePos.x + plane->getContentSize().width / 4,
			PlanePos.y + plane->getContentSize().height / 2+10));

		spritebullet1->setPosition(bulletPos1);
		spritebullet1->setScale(0.8f);

		spritebullet2->setPosition(bulletPos2);
		spritebullet2->setScale(0.8f);

	    float flyVelocity = 500;//运行速度，可以自己控制，每秒所走的像素
		float flyLen = winSize.height - PlanePos.y;
		float realFlyDuration = flyLen / flyVelocity;//实际飞行的时间

		//子弹运行的距离和时间，从飞机处开始运行到屏幕顶端
		auto actionMove1 = MoveTo::create(realFlyDuration,
			Point(bulletPos1.x, winSize.height));

		auto actionMove2 = MoveTo::create(realFlyDuration,
			Point(bulletPos2.x, winSize.height));

		//子弹执行完动作后进行函数回调，调用移除子弹函数
		auto actionDone = CallFuncN::create(
			CC_CALLBACK_1(HeroBulletTwo::removeBullet, this));

		//子弹开始跑动
		Sequence* sequence1 = Sequence::create(actionMove1, actionDone, NULL);
		spritebullet1->runAction(sequence1);

		Sequence* sequence2 = Sequence::create(actionMove2, actionDone, NULL);
		spritebullet2->runAction(sequence2);

	}

2.4 发射三个子弹的类

HeroBulletThree.h,注意，直接继承

/**
*功能 每次发射三个子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/
#pragma once
#ifndef __HeroBulletThree_H__
#define __HeroBulletThree_H__
#include "cocos2d.h"
#include "BulletStyle.h"
USING_NS_CC;
class HeroBulletThree : public BulletStyle {
public:
	virtual void shootBullet(float dt);

};
#endif

实现文件：

/**
*功能 每次发射三个子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.14
*/

#include "HeroBulletThree.h"

void HeroBulletThree::shootBullet(float dt) {
		Size winSize = Director::getInstance()->getWinSize();
		auto PlanePos = plane->getPosition();
		double angle = M_PI * 80 / 180;//旋轉的角度
		//从缓存中创建子弹
		auto spritebullet = Sprite::createWithTexture(bulletBatchNode->getTexture());
		auto spritebullet1 = Sprite::createWithTexture(bulletBatchNode->getTexture());
		spritebullet1->setRotation(-angle);
		auto spritebullet2 = Sprite::createWithTexture(bulletBatchNode->getTexture());
		spritebullet2->setRotation(angle);
		//将创建好的子弹添加到BatchNode中进行批次渲染
		bulletBatchNode->addChild(spritebullet);
		bulletBatchNode->addChild(spritebullet1);
		bulletBatchNode->addChild(spritebullet2);
		//将创建好的子弹添加到容器
		vecBullet.pushBack(spritebullet);
		vecBullet.pushBack(spritebullet1);
		vecBullet.pushBack(spritebullet2);

		Point bulletPos = (Point(PlanePos.x,
			PlanePos.y + plane->getContentSize().height / 2 + 20));

		Point bulletPos1 = (Point(PlanePos.x - plane->getContentSize().width / 4-10,
			PlanePos.y + plane->getContentSize().height / 2+10 ));

		Point bulletPos2 = (Point(PlanePos.x + plane->getContentSize().width / 4+10,
			PlanePos.y + plane->getContentSize().height / 2+10));

		spritebullet->setPosition(bulletPos);
		spritebullet->setScale(0.8f);

		spritebullet1->setPosition(bulletPos1);
		spritebullet1->setScale(0.8f);

		spritebullet2->setPosition(bulletPos2);
		spritebullet2->setScale(0.8f);

	    float flyVelocity = 500;//运行速度，可以自己控制，每秒所走的像素

		float flyLen = winSize.height - PlanePos.y;
		float flyLen1 = PlanePos.x / cos(angle);//按照度來算
		float flyLen2 = (winSize.width - PlanePos.x) / cos(angle);

		float realFlyDuration = flyLen / flyVelocity;//实际飞行的时间
		float realFlyDuration1 = flyLen1 / flyVelocity;//实际飞行的时间
		float realFlyDuration2 = flyLen2 / flyVelocity;//实际飞行的时间

		//子弹运行的距离和时间，从飞机处开始运行到屏幕顶端
		auto actionMove = MoveTo::create(realFlyDuration,
			Point(bulletPos.x, winSize.height));

		auto actionMove1 = MoveTo::create(realFlyDuration1,
			Point(0, PlanePos.x*tan(angle) + PlanePos.y));

		auto actionMove2 = MoveTo::create(realFlyDuration2,
			Point(winSize.width, (winSize.width - PlanePos.x)*tan(angle) + PlanePos.y));

		//子弹执行完动作后进行函数回调，调用移除子弹函数
		auto actionDone = CallFuncN::create(
			CC_CALLBACK_1(HeroBulletThree::removeBullet, this));

		//子弹开始跑动
		Sequence* sequence = Sequence::create(actionMove, actionDone, NULL);
		spritebullet->runAction(sequence);

		Sequence* sequence1 = Sequence::create(actionMove1, actionDone, NULL);
		spritebullet1->runAction(sequence1);

		Sequence* sequence2 = Sequence::create(actionMove2, actionDone, NULL);
		spritebullet2->runAction(sequence2);

	}

2.5、子弹管理器编写

/**
*功能 管理子弹、切换不同的子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/
#pragma once
#ifndef __HeroBulletLayer_H__
#define __HeroBulletLayer_H__
#include "cocos2d.h"
#include "BulletStyle.h"
#include "HeroBulletOne.h"
#include "HeroBulletTwo.h"
#include "HeroBulletThree.h"

class HeroBulletLayer : public cocos2d::Layer
{
public:
	HeroBulletLayer(Node* heroPlane);
	virtual bool init();

	//根据英雄飞机创建子弹
	static HeroBulletLayer* create(Node* heroPlane);
	//改变子弹
	void changeBullet(int bulletNumber);
public:

	Node* heroPlane;//传入的英雄飞机
	BulletStyle *mBulletStyle;//子弹类型
	int bulletNumber;//当前子弹编号
};
#endif

实现文件：

/**
*功能 管理子弹、切换不同的子弹
*作者 林炳文（[email protected] 博客：http://blog.csdn.net/evankaka）
*时间 2015.3.31
*/
#include "HeroBulletLayer.h"
HeroBulletLayer::HeroBulletLayer(Node* heroPlane) {
	this->heroPlane = heroPlane;
	mBulletStyle = NULL;
	bulletNumber = 1;
}
/**
*创建子弹的静态方法
*@param heroPlane为英雄飞机
*/
HeroBulletLayer* HeroBulletLayer::create(Node* heroPlane){
	HeroBulletLayer* pRet = new HeroBulletLayer(heroPlane);
	if (pRet&&pRet->init()){
		pRet->autorelease();
		return pRet;
	}
	else{
		delete pRet;
		pRet = NULL;
		return NULL;
	}

}
bool HeroBulletLayer::init() {
	bool bRet = false;
	do {
		CC_BREAK_IF(!Layer::init());

		mBulletStyle = new HeroBulletOne();
		mBulletStyle->autorelease();
		mBulletStyle->createBullet(heroPlane);
		this->addChild(mBulletStyle);
		bRet = true;
	} while (0);
	return bRet;
}
/**
*切换不同的子弹
*@param number 表示子弹的数目
*/
void HeroBulletLayer::changeBullet(int number){

	switch (number)
	{
	case 1:
		if (bulletNumber != 1){
			this->removeChild(mBulletStyle, true);
		mBulletStyle = new HeroBulletOne();
		bulletNumber = 1;
		mBulletStyle->createBullet(heroPlane);
		mBulletStyle->autorelease();
		this->addChild(mBulletStyle);
		}
		break;
	case 2:
		if (bulletNumber != 2){
			this->removeChild(mBulletStyle, true);
			mBulletStyle = new HeroBulletTwo();
			bulletNumber = 2;
			mBulletStyle->createBullet(heroPlane);
			mBulletStyle->autorelease();
			this->addChild(mBulletStyle);
		}
		break;
	case 3:
		if (bulletNumber != 3){
			this->removeChild(mBulletStyle, true);
			mBulletStyle = new HeroBulletThree();
			bulletNumber = 3;
			mBulletStyle->createBullet(heroPlane);
			mBulletStyle->autorelease();
			this->addChild(mBulletStyle);
		}
		break;
	default:
		break;
	}

}

2.6、调用方法

    游戏入口主文件 GameMain.h添加头文件

     #include "HeroBulletLayer.h"//这是子弹管理的层

    增加变量：

    HeroBulletLayer *mHeroBulletLayer;


    然后是实现方法中GameMain.cpp的init()函数中增加

//加子弹
    mHeroBulletLayer = HeroBulletLayer::create(mHeroPlane);
    this->addChild(mHeroBulletLayer,1);

注意mHeroPlane是你的英雄飞机类，是上文中可以跟随手指运动的手机，不懂看这里，Cocos2d-x《雷电大战》(2)-精灵随手指移动，你点哪我走哪！这里还没写成单例模式的，后头会再来改！
然后就是切换子弹啦：
你只需要在要切换子弹的地方：
发射一个子弹

mHeroBulletLayer->changeBullet(1);

发射二个子弹

mHeroBulletLayer->changeBullet(2);

发射三个子弹

mHeroBulletLayer->changeBullet(3);

这里我为了测试，设置成每个5秒自动切换子弹类型：
GameMain.h加个变量

int number;//表示当前子弹的类型

GameMain.cpp中init（）函数中增加：

//每隔5S改變一次子子彈類型
    number = 1;
    schedule(schedule_selector(GameMain::changeBullet),5.0f);

下面是定时器的方法

void GameMain::changeBullet(float dt){
	if (number == 1){
		mHeroBulletLayer->changeBullet(2);
		number = 2;
	}
	else if (number == 2){
		mHeroBulletLayer->changeBullet(3);
		number = 3;
	}
	else if (number == 3)
	{
		mHeroBulletLayer->changeBullet(1);
		number = 1;
	}

	CCLOG("CHANGE");

}

效果：
这里它会自动每隔5s切换不同的子弹，由于上传图片的限制。只能这样了。

三、总结

是不是很方便呢？当我需要增加一个子弹类型时，我只需要继承BulletStyle.然后重写函数shootBullet(float dt) 即可。然后在需要更改子弹的位置bool HeroBulletLayer::changeBullet(int number)增加每4种子弹。第5种子弹......这样就增加了代码的复用性，而且很容易懂。也省去了一大堆的if-else判断。

林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

时间： 2024-08-17 14:13:14

Cocos2d-x《雷电大战》(4)-策略模式实现不同子弹切换！！的相关文章

Cocos2d-x游戏《雷电大战》开源啦!要源码要资源快快来～～

写在前面的话:这是笔者开发的第二个小游戏<雷电大战>,之前就过这个游戏和<赵云要格斗>一样,最终将会开源.由于自己的一些个人原因.这个游戏还没有完成,但是许多网友都过来寻求代码或资源,本着开源的精神,笔者今天将它们共享给出大家. 注:目前游戏还没有完成,代码全是笔者原创,资源有一部分原创,有一部分网上搜集. 若是觉得本项目对你有用,那么请给辛苦的笔者的GitHub右上角Star一颗星星!不胜感激---- 下载地址 https://github.com/appleappleapple

一、策略模式

概念: 策略模式是指对一系列的算法定义,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法独立于使用它的客户而独立变化. 简单来说,策略模式即是指在程序运行的时候可以自由地选择一系列算法中的某一个. 如图: 功能类通过替换类中的策略,来执行不同具体实现.下面列出代码: public class StrategyDemo { public static void main(String[] args) { // 更换策略为strategy1 StrategyContext strat

Cocos2d-x《雷电大战》(5)-单例模式英雄飞机闪亮登场!

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 本文将实现用单例模式实现一个英雄飞机类的设计,单例模式是游戏开发中最常用到的一种设计模式,原理也比较简单,仔细研究下就可以掌握好. 来看看效果: Cocos2d-x版本:3.4 工程环境:VS30213 一.单例模式解析 单例模式也称为单件模式.单子模式,可能是使用最广泛的设计模式.其意图是保证一个类仅有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享.有很多地方需要这样的功

Cocos2d-x《雷电大战》(3)-子弹无限发射

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 本文要实现雷电游戏中,游戏一開始,英雄飞机就无限发射子弹的功能. 这里的思想是单独给子弹弄一个层.在这个层不设置一个定时器,每隔一个时间,依据当前英雄飞机传入的位置,生成子弹,并设置子弹的移动事件,和移动后的事件(就是把子弹删除掉,节省内存). 终于效果: Cocos2d-x版本号:3.4 project环境:VS30213 一.英雄子弹层 1.HeroBulletLayer.h /** *

一起学习设计模式-策略模式

大家好: 我近期写了一个TCP长连接的框架,封装的Netty,序列化采用的是PB,内存缓存用的Google的Guava.项目托管在GitHub上,开源希望大家能用起来并且一起维护这个项目.我是做游戏服务器的,像客户端的引擎框架有Cocos2d , Unity等.而服务器没有相对来说比较好的开源的架构(或者说鄙人学识浅薄没有发现).我也经历了几个游戏从开发到上线的这样一个过程,所以也看到过几个比较优秀的框架,现在的想法是能够开源一个服务器框架,然后大家各抒己见共同维护这个框架.因为我的经验尚短,框

设计模式(Python)-策略模式

本系列文章是希望将软件项目中最常见的设计模式用通俗易懂的语言来讲解清楚,并通过Python来实现,每个设计模式都是围绕如下三个问题: 为什么?即为什么要使用这个设计模式,在使用这个模式之前存在什么样的问题? 是什么?通过Python语言来去实现这个设计模式,用于解决为什么中提到的问题. 怎么用?理解了为什么我们也就基本了解了什么情况下使用这个模式,不过在这里还是会细化使用场景,阐述模式的局限和优缺点. 这一篇我们先来看看策略模式. 为什么? 假设我们有如下一个项目: 飞机大战游戏中,玩家可以选择

PHP设计模式-策略模式

<?php//策略模式//将一组特定的算法或行为 封装成一个类,以适应上下文环境 //策略的接口文件 约定策略的行为 针对一种情况 产生具体的策略interface Policy{ function showAd();} class Female implements Policy{ public function showAd() { echo __CLASS__.' policy'; }} class Male implements Policy{ public function showA

对设计模式的总结之简单工厂与策略模式

前言 面向对象编程追求的本质-提高扩展性.可维护性.灵活性和复用性.合理利用面向对象6个原则,能够很好的达到要求.如何利用好就是至关重要的了,前人总结了23+个设计模式能够让初学者更容易学到其中的精髓,本文就说说我对本人对简单工厂模式.策略模式的见解. 简单工厂模式与策略模式 简单工厂模式 工作中,常常遇到需要做一个功能(鸭子),这个功能中含有可控个数的子操作功能(鸭子叫,鸭子跑,鸭子飞),而且子功能在不同的情况下处理方式又不相同(成年鸭子/小鸭子叫,成年鸭子/小鸭子跑,成年鸭子/小鸭子飞).我

Java 策略模式

Java 策略模式 @author ixenos 定义 1.封装算法:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换 2.分割行为和环境:对用户屏蔽内部实现,使客户端在调用算法的时候能够互不影响地互换 策略模式的实现(面向接口编程) 方法: 1.接口多态:策略模式的用意是针对一组算法,将每个算法封装到具有共同接口的独立的类中,从而使他们之间可以相互替换 2.具体策略提供不同算法,环境负责维持和查询策略,把具体策略和环境分割开来,使得算法可以在不影响客户端和环境的情况下修改 角色分工: