谋略模式与简单java实例

策略模式与简单java实例
策略模式的定义：定义了算法簇，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

首先看策略模式的定义，算法簇也就是一群实现了同一个接口的实现类，让它们之间可以相互替换的意思也就是要针对接口编程，而不是针对类编程。此模式让算法的变化独立于使用算法的客户是说，采用何种算法只取决于调用者。

现在说说例子：
一个格斗游戏，角色类Fighter可以使用很多武器，不同武器攻击力以及特殊效果不同，比如使用剑能有一定几率造成额外伤害，斧子有一定几率造成双倍伤害。如果不使用模式的情况下实现这个游戏的话,Fighter就应该有一些方法：attackWithSword()，attackWithAxe()。如果剑类武器又有：铁剑、霜之哀伤，又要为这两把剑写两个方法。如果有1000个武器呢？（当然实现这个的方法还有很多，尤其是笨方法很多。。。）
为了避免以上情况，我们定义一个接口：

package com.Weapon;import com.fighter.Fighter;public interface WeaponBehavior {public void attackWithWeapon(Fighter fighter); public String getName();public void setName(String name);}

让所有武器去实现这个接口，所有实现了这个接口的类，都叫算法簇。

现在，抽象类剑，实现了这个接口，这里剑是一个种类，而不是一个具体武器，所以是抽象类：

package com.Weapon;import java.util.Random;import com.fighter.Fighter;//剑类武器有一定几率造成额外的伤害public abstract class Sword implements WeaponBehavior {// 普通伤害int damage;String name;// 特殊攻击的伤害int specialDamage;// 特殊攻击的触发几率int probability;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getDamage() {return damage;}public void setDamage(int damage) {this.damage = damage;}@Overridepublic void attackWithWeapon(Fighter fighter) {normalAttack(fighter);specialAttack(fighter);}protected void normalAttack(Fighter fighter) {System.out.println("用" + this.getName() + "对" + fighter.getName()+ "造成了" + this.getDamage() + "基本伤害。");fighter.loseLife(this.getDamage());}protected void specialAttack(Fighter fighter) {Random r = new Random();int i = r.nextInt(100);if (i < this.probability) {System.out.println(this.getName() + "触发了特殊效果，对" + fighter.getName()+ "造成了" + this.specialDamage + "点额外伤害。");fighter.loseLife(this.specialDamage);}}}

剑这个类里定义了伤害值，特殊攻击的伤害值,特殊攻击的触发几率，并且在这里定义了特殊攻击的算法。这样做有什么好处呢？看了子类就知道了：

package com.Weapon;import com.fighter.Fighter;/* * 霜之哀伤，攻击力100，有百分之50造成额外的50点伤害。 * */public class Frostmourne extends Sword {public Frostmourne(){this.setName("霜之哀伤");this.setDamage(100);specialDamage=50;probability=50;}@Overrideprotected void specialAttack(Fighter fighter) {super.specialAttack(fighter);}}

大家看到了，子类很简单，只要定义一下名字，伤害，以及特殊攻击伤害、特殊攻击几率而已，因为具体算法实现已经由父类实现了。

同样的，还有斧类武器：

package com.Weapon;import java.util.Random;import com.fighter.Fighter;//斧类武器有一定几率造成双倍伤害public abstract class Axe implements WeaponBehavior {// 普通伤害int damage;String name;// 特殊攻击的伤害int specialDamage;// 特殊攻击的触发几率int probability;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getDamage() {return damage;}public void setDamage(int damage) {this.damage = damage;}@Overridepublic void attackWithWeapon(Fighter fighter) {normalAttack(fighter);specialAttack(fighter);}protected void normalAttack(Fighter fighter) {System.out.println("用" + this.getName() + "对" + fighter.getName()+ "造成了" + this.getDamage() + "基本伤害。");fighter.loseLife(this.getDamage());}protected void specialAttack(Fighter fighter) {Random r = new Random();//斧子有一定几率造成双倍伤害this.specialDamage=damage*2;int i = r.nextInt(100);if (i < this.probability) {System.out.println(this.getName() + "触发了特殊效果，对" + fighter.getName()+ "造成了" + this.specialDamage + "点额外伤害。");fighter.loseLife(this.specialDamage);}}}

package com.Weapon;import com.fighter.Fighter;/* * 公正使者，攻击力100，有百分之30几率造成双倍伤害。 * */public class Axe1 extends Axe {public Axe1(){this.setName("公正使者");this.setDamage(100);probability=30;}@Overrideprotected void specialAttack(Fighter fighter) {super.specialAttack(fighter);}}

武器就写这么多吧，现在看看Fighter,它就是策略模式定义中的使用算法的客户

package com.fighter;import com.Weapon.WeaponBehavior;public class Fighter {private int life;private String name;private WeaponBehavior weapon;public Fighter(String name,WeaponBehavior weapon){this.weapon=weapon;this.name=name;this.life=1000;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void hit(Fighter fighter){this.weapon.attackWithWeapon(fighter);}public int getLife() {return life;}private void setLife(int life) {this.life = life;}public WeaponBehavior getWeapon() {return weapon;}public void setWeapon(WeaponBehavior weapon) {this.weapon = weapon;}public void loseLife(int damage){this.setLife(this.getLife()-damage);}public void changeWeapon(WeaponBehavior weapon){System.out.println(this.getName()+"装备了"+weapon.getName());this.setWeapon(weapon);}}

可以看到，Fighter攻击的时候只是去调用了自身武器的attackWithWeapon(Fighter fighter)方法。这就证实了策略模式的定义，定义了算法簇，分别封装起来，让他们之间可以相互替换,这些武器就是算法簇，使用者只要更换掉自己想要使用的实现类就行了，在调用算法的时候，依然只是调用算法实现的接口。

看下测试类

package com.main;import com.Weapon.Axe1;import com.Weapon.Frostmourne;import com.fighter.Fighter;public class Main {public static void main(String[] args) {Fighter player=new Fighter("player",new Frostmourne());Fighter computer=new Fighter("computer",new Frostmourne());player.hit(computer);System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");player.hit(computer);System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");                  //这里更换了算法（武器）player.changeWeapon(new Axe1());player.hit(computer);System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");player.hit(computer);System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");player.hit(computer);System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");player.hit(computer);System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");}}

测试结果：

用霜之哀伤对computer造成了100基本伤害。霜之哀伤触发了特殊效果，对computer造成了50点额外伤害。computer还剩下850生命用霜之哀伤对computer造成了100基本伤害。霜之哀伤触发了特殊效果，对computer造成了50点额外伤害。computer还剩下700生命player装备了公正使者用公正使者对computer造成了100基本伤害。computer还剩下600生命用公正使者对computer造成了100基本伤害。公正使者触发了特殊效果，对computer造成了200点额外伤害。computer还剩下300生命用公正使者对computer造成了100基本伤害。computer还剩下200生命用公正使者对computer造成了100基本伤害。computer还剩下100生命

1 楼 ottoliu 2010-11-26   借宝地 也想发表点看法 我就觉得楼主的 例子不错 我也是新人
在我看来 这个对我 比那些高深的内容 更加有帮助

新人都是爬楼梯者 不是天才的攀岩者
我们需要一阶一阶的台阶来 爬的更高 更稳  而不想看见你们在悬崖上笑 无所作为

有感而发 仅此而已 2 楼 Quen 2010-11-28   觉得例子很不错！学习了！ 3 楼 fangshengcai001 2011-04-11   学习了...

查看更多 下一篇