通过《植物大战僵尸》学策略模式

最新推荐文章于 2022-09-09 10:53:15 发布
最新推荐文章于 2022-09-09 10:53:15 发布
阅读量940 收藏 5
点赞数
分类专栏： 设计模式 文章标签： 设计模式 design pattern java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47623997/article/details/106595399
版权

案例

《植物大战僵尸》这个游戏很多人都玩过，里面有各种不同的植物和僵尸。不同的植物、僵尸各自有不同的特点。假如你要开发这样一款游戏，游戏最开始的版本比较简单，只有两种僵尸：普通僵尸、旗手僵尸。

第一版

类型外观移动攻击
普通僵尸普通朝着一个方向咬
旗手僵尸普通+手持旗子朝着一个方向咬

抽象类：

abstract class AbstractZombie{
	
	public abstract void display();

	public void attack(){
		System.out.println("咬");
	}

	public void move(){
		System.out.println("一步一步移动");
	}
}

普通僵尸：

class NormalZombie extends AbstractZombie{

	@Override
	public void display() {
		System.out.println("我是普通僵尸");
	}
}

旗手僵尸：

class FlagZombie extends AbstractZombie{

	@Override
	public void display() {
		System.out.println("我是旗手僵尸");
	}
}

测试：

public class ZombieTest {

	public static void main(String[] args) {
		AbstractZombie normalZombie = new NormalZombie();
		AbstractZombie flagZombie = new FlagZombie();

		flagZombie.display();
		flagZombie.move();
		flagZombie.attack();
		System.out.println("---------------");

		normalZombie.display();
		normalZombie.move();
		normalZombie.attack();
	}

}

执行结果：

我是旗手僵尸
一步一步移动
咬
---------------
我是普通僵尸
一步一步移动
咬

完美！游戏可以上线了。
但是没过多久你发现你开发的这个游戏玩家越来越少，打开评论一看，都在吐槽这个游戏僵尸种类太少，玩了几次就没啥意思了。
这好办，再加几种僵尸呗，于是就有了第二版：

第二版

类型外观移动攻击
普通僵尸普通朝着一个方向咬
旗手僵尸普通+手持旗子朝着一个方向咬
投篮僵尸带着篮球朝着一个方向投球
撑杆僵尸带着杆会撑杆跳咬

这简单，我再写俩僵尸类，然后重写跟抽象僵尸类（AbstractZombie）不一样的方法实现就行。

投篮僵尸：

class BallZombie extends AbstractZombie{

	@Override
	public void display() {
		System.out.println("我是投球僵尸");
	}

	@Override
	public void attack() {
		System.out.println("投球");
	}
}

撑杆僵尸：

class PoleVaultZombie extends AbstractZombie{

	@Override
	public void display() {
		System.out.println("我是撑杆僵尸");
	}

	@Override
	public void move() {
		System.out.println("撑杆跳");
	}
}

你突然想到还可以加一种高级撑杆跳僵尸,移动方式跟撑杆跳僵尸一样，但是这个僵尸攻击方式是拿杆戳植物。好办，这个直接继承撑杆僵尸。

class SuperPoleVaultZombie extends PoleVaultZombie{

	@Override
	public void display() {
		System.out.println("我是高级撑杆僵尸");
	}

	@Override
	public void attack() {
		System.out.println("戳");
	}
}

搞定！第二版上线！

但是历史总是惊人的相似，没过多久用户们又玩腻了，你心想这届用户真难带，又要加僵尸了。不过还好你已经得心应手了，不就是各种继承吗,你继承写的贼6~

但是只是无脑加僵尸哪够，还有一堆用户吐槽你这游戏的BUG：你这僵尸遇到障碍物都不带停的，遇到植物应该停止移动,开始攻击；而且撑杆僵尸明明应该在没有遇到植物时候是跑的，遇到第一个植物才会撑杆跳。所以这些僵尸的各个行为在不同情况下是不一样的，这可咋办，你已经写了一堆僵尸类了，难倒要挨个类加判断逻辑改变行为？真叫人头秃！！！这个时候你想到了开闭原则:对扩展开放，对修改关闭。看来你的代码需要重构一下了。

僵尸的移动方式和攻击方式有不同的实现方式，而且要可以动态改变。先把这两个行为抽取成接口。

移动行为接口：

interface MoveBehavior {
	void move();
}

攻击行为接口

interface AttackBehavior {
	void attack();
}

抽象类

abstract class AbstractZombie {

	MoveBehavior moveBehavior;
	AttackBehavior attackBehavior;

	public AbstractZombie(MoveBehavior moveBehavior, AttackBehavior attackBehavior){
		this.moveBehavior = moveBehavior;
		this.attackBehavior = attackBehavior;
	}

	abstract void display();

	void move(){
		moveBehavior.move();
	}

	void attack(){
		attackBehavior.attack();
	}

	public void setAttackBehavior(AttackBehavior attackBehavior) {
		this.attackBehavior = attackBehavior;
	}

	public AttackBehavior getAttackBehavior() {
		return attackBehavior;
	}

	public void setMoveBehavior(MoveBehavior moveBehavior) {
		this.moveBehavior = moveBehavior;
	}

	public MoveBehavior getMoveBehavior() {
		return moveBehavior;
	}
}

各种僵尸子类：

class NormalZombie extends AbstractZombie {

	public NormalZombie(MoveBehavior moveBehavior, AttackBehavior attackBehavior) {
		super(moveBehavior, attackBehavior);
	}

	@Override
	void display() {
		System.out.println("我是普通僵尸");
	}

}

class FlagZombie extends AbstractZombie {

	public FlagZombie(MoveBehavior moveBehavior, AttackBehavior attackBehavior) {
		super(moveBehavior, attackBehavior);
	}

	@Override
	void display() {
		System.out.println("我是旗手僵尸");
	}
}

class BallZombie extends AbstractZombie {

	public BallZombie(MoveBehavior moveBehavior, AttackBehavior attackBehavior) {
		super(moveBehavior, attackBehavior);
	}

	@Override
	void display() {
		System.out.println("我是投篮僵尸");
	}
}

class PoleVaultZombie extends AbstractZombie {

	public PoleVaultZombie(MoveBehavior moveBehavior, AttackBehavior attackBehavior) {
		super(moveBehavior, attackBehavior);
	}

	@Override
	void display() {
		System.out.println("我是撑杆僵尸");
	}
}

移动行为子类：

class StepByStepMove implements MoveBehavior{

	@Override
	public void move() {
		System.out.println("一步一步移动");
	}
}

class RunMove implements MoveBehavior{

	@Override
	public void move() {
		System.out.println("跑");
	}
}

class PoleVaultMove implements MoveBehavior{

	@Override
	public void move() {
		System.out.println("撑杆跳");
	}
}

攻击行为子类：

class BiteAttack implements AttackBehavior{

	@Override
	public void attack() {
		System.out.println("咬");
	}
}

class BallAttack implements AttackBehavior{

	@Override
	public void attack() {
		System.out.println("扔球");
	}
}

测试：

public class StrategyTest {
	
	public static void main(String[] args) {
		
		NormalZombie normalZombie = new NormalZombie(new StepByStepMove(), new BiteAttack());
		normalZombie.display();
		normalZombie.move();
		normalZombie.attack();
		System.out.println("-----------");

		FlagZombie flagZombie = new FlagZombie(new StepByStepMove(), new BiteAttack());
		flagZombie.display();
		flagZombie.move();
		flagZombie.attack();
		System.out.println("-----------");

		BallZombie ballZombie = new BallZombie(new StepByStepMove(), new BallAttack());
		ballZombie.display();
		ballZombie.move();
		ballZombie.attack();
		System.out.println("-----------");

		PoleVaultZombie poleVaultZombie = new PoleVaultZombie(new RunMove(), new BiteAttack());
		poleVaultZombie.display();
		poleVaultZombie.move();
		//如果撑杆僵尸遇到了第一个植物
		System.out.println("我遇到了第一个植物");
		poleVaultZombie.setMoveBehavior(new PoleVaultMove());
		poleVaultZombie.move();
		poleVaultZombie.attack();

	}
}

执行结果：

我是普通僵尸
一步一步移动
咬
-----------
我是旗手僵尸
一步一步移动
咬
-----------
我是投篮僵尸
一步一步移动
扔球
-----------
我是撑杆僵尸
跑
我遇到了第一个植物
撑杆跳
咬

从此以后你想改某个僵尸的行为都不需要去改僵尸类，直接传一个不同的行为实例给僵尸就行。而且可以根据不同情况随便修改各个僵尸的行为。完美！

这就是策略模式。

模式定义

策略模式（Strategy） 指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法。
策略模式定义了算法家族，分别封装了起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到算法的使用者。

类图

策略模式类图
案例中僵尸就是环境角色Context，两个行为接口就是抽象策略Strategy，具体的移动、攻击子类就是具体实现策略ConcreteStrategy

应用场景

  1. 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。
  2. 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。
  3. 对客户隐藏具体策略(算法)的实现细节，彼此完全独立。

优缺点

优点

  1. 策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码转移到父类里面，从而避免重复的代码。
  2. 策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。
  3. 使用策略模式可以避免使用多重条件转移语句。多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后。

缺点

  1. 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。
  2. 策略模式造成很多的策略类，每个具体策略类都会产生一个新类。有时候可以通过把依赖于环境的状态保存到客户端里面，而将策略类设计成可共享的，这样策略类实例可以被不同客户端使用。换言之，可以使用享元模式来减少对象的数量。

JDK中的策略模式

比较器Comparator

在Java的集合框架中，经常需要传入一个比较器Comparator用于排序，这使用的就是策略模式。

什么？你说你没有用过比较器？看一下下面的测试代码你就明白了

假如现在有很多只猫，需要排个序

定义一个Cat类：

class Cat implements Comparable<Cat>{

	int age;
	int weight;

	public Cat(int age,int weight){
		this.age = age;
		this.weight = weight;
	}

	@Override
	public int compareTo(Cat o) {
		return this.age - o.age;
	}

	@Override
	public String toString() {
		return "Cat{" +
				"age=" + age +
				", weight=" + weight +
				'}';
	}
}

这Cat里有age、weight，虽然实现了Comparable接口的compareTo方法，但是这个比较逻辑是不变的，永远是根据年龄排序，哪天你想根据体重排序就要去修改Cat里的compareTo方法。

所以我们定义两个比较器：

class SortByAge implements Comparator<Cat> {

	@Override
	public int compare(Cat o1, Cat o2) {
		return o1.age - o2.age;
	}
}

class SortByWeight implements Comparator<Cat> {

	@Override
	public int compare(Cat o1, Cat o2) {
		return o1.weight - o2.weight;
	}
}

测试：

public class CatSortTest {

	public static void main(String[] args) {
		List<Cat> list = new ArrayList<>();
		list.sort(new SortByAge());
		list.add(new Cat(1,8));
		list.add(new Cat(3,2));
		list.add(new Cat(4,5));
		list.add(new Cat(2,7));
		list.add(new Cat(5,3));

		System.out.println("使用Cat类中实现了Comparable的compareTo方法排序");
		Collections.sort(list);
		System.out.println(list);
		System.out.println("---------");

		System.out.println("使用SortByAge比较器排序");
		//和list.sort(new SortByAge())效果一样
		Collections.sort(list,new SortByAge());
		System.out.println(list);
		System.out.println("---------");

		System.out.println("使用SortByWeight比较器排序");
		//和list.sort(new SortByWeight())效果一样
		Collections.sort(list,new SortByWeight());
		System.out.println(list);

	}
}

打印结果：

使用Cat类中实现了Comparable的compareTo方法排序
[Cat{age=1, weight=8}, Cat{age=2, weight=7}, Cat{age=3, weight=2}, Cat{age=4, weight=5}, Cat{age=5, weight=3}]
---------
使用SortByAge比较器排序
[Cat{age=1, weight=8}, Cat{age=2, weight=7}, Cat{age=3, weight=2}, Cat{age=4, weight=5}, Cat{age=5, weight=3}]
---------
使用SortByWeight比较器排序
[Cat{age=3, weight=2}, Cat{age=5, weight=3}, Cat{age=4, weight=5}, Cat{age=2, weight=7}, Cat{age=1, weight=8}]

这里Collections就是环境角色Context，Comparator就是抽象策略Strategy，两个比较器实现就是具体实现策略ConcreteStrategy

ThreadPoolExecutor中的拒绝策略

在创建线程池时，需要传入拒绝策略，当创建新线程使当前运行的线程数超过maximumPoolSize时，将会使用传入的拒绝策略进行处理。这也是策略模式。

  • AbortPolicy：直接抛出异常
  • CallerRunsPolicy：在任务被拒绝添加后，会调用当前线程池的所在的线程去执行被拒绝的任务
  • DiscardPolicy：不处理，直接丢弃
  • DiscardOldestPolicy：当任务被拒绝添加时，会抛弃任务队列中最旧的任务也就是最先加入队列的，再把这个新任务添加进去
CoderKK123
关注
专栏目录
❤️❤️❤️Unity废柴看过来，手把手教你做植物大战僵尸（八）—— 战斗逻辑总结
小姑娘不爱写代码
08-04 3549
植物大战僵尸 一、复制我方的向日葵和豌豆，并运动 1、准备1： （1）创建背景纹理 （2）向日葵豌豆的精灵模板 2、准备2： （1）在背景上添加Grid（表格），排列好Cell（单元格） （2）添加碰撞盒（向日葵和豌豆的精灵模板、单元格） 3、（1）给向日葵和豌豆精灵模板添加拖曳组件 （2）重写拖曳开始方法，显示向日葵或豌豆 （3）重写拖曳释放方法，放入单元格中不删除 注意：新建Layer命名Grid，把UI Root下子物体的Layer设置成Grid （4）单元格下如果有植物，不能再重复放置 4、（1）使
植物大战僵尸设计元素浅析
LLL_Sicily的博客
09-12 3592
目录介绍原因游戏介绍基本介绍游戏故事背景大致玩法开发框架个人比较喜欢的部分植物部分Cob Cannon玉米加农炮Tall-nut高坚果（巨型坚果墙壁）Puff-shroom小喷菇（喷射蘑菇）僵尸部分模式其他--满足强迫症患者浅谈为何会受欢迎 介绍原因 小时候对游戏其实兴趣不大，真正开始特别喜欢一个游戏就是植物大战僵尸了，现在还记得当时和我哥一起第一次轮流快速刷关的场景，刷完之后又玩无尽模式，最后游...
用Java语言，写一个植物大战僵尸简易版！
Xn346的博客
03-30 687
前言 有谁没玩过植物大战僵尸吗？ 小灰的一位读者，用Java语言开发了自己的植物大战僵尸游戏。虽然系统相对简单，但是麻雀虽小五脏俱全，对游戏开发感兴趣的小伙伴可以学习一下哦~~ 游戏设计 植物大战僵尸中有一个小游戏关卡，屏幕的正上方有一个滚轮机，会随机生成植物，玩家可以选中植物后自由选择草坪来进行安放。基于此游戏模式，我将该关卡抽取出来，单独做成了一个简易版的植物大战僵尸。游戏的画面大概如下： 屏...
植物大战僵尸 [费用提前计算]
AnnieL
03-17 1216
问题描述 　　　何老板喜欢玩植物大战僵尸，在游戏里有一条水平道路，道路的一端是入口，另一端是房子。僵尸会从道路的入口一端向房子一端移动。这条道路刚好穿过N块连续的空地。初始时，僵尸通过每块空地的时间是T秒。玩家可以在这N个空地中种植植物以攻击经过的僵尸，每块空地中只能种植一种植物。 　　　共有三种不同类型的植物，分别是红草、蓝草和绿草，作用分别是攻击、减速以及下毒。每种植物只能在僵尸通过它所在...
【植物大战僵尸2】算法 笔记
Dontla的博客
03-12 1464
文章目录春日活动--旅行原木--特殊事件--植物挑战_超能花菜 春日活动–旅行原木–特殊事件–植物挑战_超能花菜
Unity 3D的植物大战僵尸源码.zip
07-08
尽管“植物大战僵尸”主要是单人游戏，但源码可能包含一些关于网络同步的代码，用于多人合作或竞技模式的开发。Unity 3D提供了UNet等网络框架，用于处理玩家间的交互和数据同步。 七、优化与性能调试 为了保证游戏...
植物大战僵尸源码unity
11-10
《植物大战僵尸》是一款深受玩家喜爱的塔防游戏，它以独特的策略性和可爱的画风吸引了全球无数玩家。Unity引擎作为一款强大的跨平台游戏开发工具，被广泛用于制作2D和3D游戏，包括《植物大战僵尸》这样的经典作品。...
---植物大战僵尸素材包
06-23
《植物大战僵尸》是一款深受玩家喜爱的塔防类游戏，其独特的策略性和丰富的游戏元素吸引了全球范围内的广大玩家。这个素材包中包含了游戏的各种资源，包括图像、声音、动画等，是开发者或爱好者进行游戏二次创作的...
植物大战僵尸素材与源码
最新发布
09-25
《植物大战僵尸》是一款深受玩家喜爱的塔防类游戏，其独特的人物设定、丰富的关卡设计和策略性玩法使得这款游戏在全球范围内拥有大量的忠实粉丝。在这个压缩包中，包含的是该游戏的部分素材与源码，这对于想要深入...
植物大战僵尸素材全.zip
01-19
2. **植物大战僵尸游戏机制**：游戏的核心是通过种植不同类型的植物来抵御僵尸的进攻。素材包中可能包含各种植物的静态图像和动画，如豌豆射手、向日葵、寒冰射手等，每种植物都有独特的攻击方式和功能。理解这些...
植物大战僵尸类模版设计
10-28
一系列模版 方便写游戏设计的文档 方便学生学习用的模版 一系列设计等等
植物大战僵尸
06-12
植物大战僵尸山寨版可以使用
僵尸大战小游戏的奇葩算法
SDLTF的Blog
02-08 465
首页 | 收藏 | 代码 | 文章 | 墙 很多童鞋都知道打僵尸游戏。这种游戏类似于你和一堆僵尸在一起，你需要蛇皮走位避免僵尸的攻击然后骚气的把僵尸打死，你才能胜利 （P.S.：不知道的小伙伴们去这个大佬的Blog下载Zombie玩玩） 但是，如果让同学们来写这个僵尸游戏，很多同学对于僵尸的移动都会这么写： //伪代码版本 if 僵尸在玩家下面 僵尸向上走 if 僵尸在玩家上面 僵尸向下走 i...
iOS开发-------MVC架构思想-植物大战僵尸
RITL_Y
10-07 1824
十月长假也就这么过去了，利用假期想磨练一下自己的MVC架构的思想，于是找了一个相对比较麻烦的Demo来锻炼下，在之前很喜欢植物大战僵尸这个游戏，也算为游戏致敬了，但是这个植物大战僵尸肯定不是之前玩过的那个游戏，只是致敬，类似打地鼠，但是代码感觉非常多，所以也算楼主的目前博客里面最有料的了，不得不说，想逻辑的时候直接的虐心啊，先看一下效果吧 然后看一下如果家中的僵尸
【NOI2009】植物大战僵尸
OI技术宅
03-02 1313
【NOI2009】植物大战僵尸 【题目描述】 Plants vs. Zombies（PVZ）是最近十分风靡的一款小游戏。Plants（植物）和Zombies（僵尸）是游戏的主角，其中：Plants防守，而Zombies进攻。该款游戏包含多种不同的挑战系列，比如Protect Your Brain、Bowling等等。其中最为经典的，莫过于玩家通过控制Plants来防守Zombies的进攻，
23种设计模式的对比和总结
那么多的人，你要去哪里
04-28 2450
通过《大话设计模式》初步了解了设计模式的一些概念，这是一个从面相过程到面相对象的思想转换，为以后的面向对象编程带来了从思想根源上的改变，很多模式看的令人兴奋，原来程序还可以这样写。 不同的模式带来不同的方法，23个模式的优点和缺点是什么？什么情况下使用什么模式？一起来看看吧。
NOI2009 植物大战僵尸
a6t2007的博客
01-11 189
题目描述 题解： 由于干每棵植物之前需要先干掉它右面的植物和保护他的植物， 我们可以发现这是最大权闭合子图问题。 简单提一下。 闭合子图，指这个子图中所有的点只会指向子图中的点。 最大权，指这些点有点权，要求得到的闭合子图点权之和最大。 解决办法是，$S$向正点权的点连容量为点权的边，负点权的点向$T$连容量为点权相反数的边。 然后正点权之和-得到的最大流即为最大权...
基于Java实现的植物大战僵尸游戏
毕业作品网站
09-09 8095
玩家通过种植太阳花收取阳光来购买植物；通过种植不同的植物来抵御僵尸的攻击。当一个关卡里的僵尸全部被消灭时，玩家胜；当僵尸越过地图的右边界时，僵尸胜利。购买植物需要花费一定数量的阳光，每购买一次过后需要冷却一段时间才能再次购买。每个关卡允许使用的植物各有不同，不同植物的特性也不同植物主要分为：攻击类，防御类和生产类。也可以分为夜间植物和白天植物（夜间植物只能在夜间出现）在游戏中，不同种类的僵尸会一波波的攻击。不同僵尸的攻击值，耐久，特性有所不同。普通僵尸游戏中最普通的花园僵尸血量：270（普通）
23种设计模式-建造者模式《植物大战僵尸开发》
热门推荐
yancyang的博客
08-29 1万+
对于许久不用的东西，容易忘记。百度许久，也未能找到自己所要。 从今日起，有些东西就记载下来，不仅方便自己，希望能帮到他人吧！ 定义： 建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 使用场景： 1 创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式。 2 构造过程必须允许被构造的对象有不同表示。 -建造者模式，有以下...
重温经典：植物大战僵尸的快乐回忆
资源摘要信息:"植物大战僵尸"是一款由PopCap Games开发的策略塔防类游戏。自2009年首次发布以来，它迅速在全球范围内获得了巨大的成功和广泛的赞誉。这款游戏以其简洁有趣的游戏机制、多样化的植物角色以及富有创意...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值