[菜鸟的设计模式之旅]策略模式
策略模式
定义
什么是策略模式?定义了算法族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。
我的理解就是:比如我们接下来要说到的鸭子案例,有的鸭子可以飞,而飞又分为很多种,飞很高,飞得很低各种,我们就会把飞这个行为定义为接口,然后再分别去实现,而我们的鸭子只需要注入“飞”的行为,就可以去飞,至于怎么飞,鸭子不用去管,这也算是面向接口编程吧。当然除了飞,还有很多行为,我们都可以把这些行为抽成接口,然后再具体实现,让鸭子有接口类型的变量,就有了对应的行为啦~当然鸭子也分很多种,比如橡皮泥鸭子,这是肯定不能飞行的,那么我们就不需要去给他设置飞行实现就好了。非常的灵活,可以面对各种变化, 比如鸭子受伤了,不能飞了,那就修改下鸭子注入的飞行行为的实现,再比如鸭子又多了一种技能,能呱呱叫了,那就再写一个呱呱叫接口,至于怎么呱呱叫,让具体的实现去解决。
接下来我来粘贴一下《head first 设计模式》上的案例即鸭子
举例
首先是鸭子抽象类:
我定义了一个flybehavior类型的变量,这个flybehavior是一个飞行行为的接口,这就意味着鸭子有了飞行行为
至于怎么飞,我们不需要考虑,交给飞行的实现去飞,也就是performfly(),同时还有一个setflybehavior(),这个方法就意味着,鸭子能够在运行时动态的修改自己飞行的实现,比如本来是“飞的很高”,后来鸭子年纪大了,飞不了很高了,那就用这个方法修改一下自己的飞行实现。比如duck.setflybehavior(new flylow());
package object; import behaviour.flybehavior; public abstract class duck { protected flybehavior flybehavior; public void setflybehavior(flybehavior flybehavior) { this.flybehavior = flybehavior; } public abstract void swim(); public abstract void display(); public void performfly(){ flybehavior.fly(); } }
有了抽象类肯定要有实现类呀,这就奉上香喷喷的"驯化野鸭”
flybehavior的变量是从父类duck继承过来的,而flywithwings是实现了flybehavior接口的"用翅膀飞行”,mallardduck的构造函数就意味着,"驯化野鸭"对飞行行为的描述默认是“用翅膀飞行”,当然如果想改变它的飞行行为,那么只需要用刚刚提到的父类中的setflybehavior()方法就好了。
package object.concreteobject; import behaviour.flywithwings; import object.duck; public class mallardduck extends duck{ public mallardduck(){ flybehavior = new flywithwings(); } @override public void swim() { // todo auto-generated method stub system.out.println("i'm swimming!"); } @override public void display() { system.out.println("i'm a real mallard duck"); } }
当然,既然是粘贴代码,就一定要粘贴全,这就附上flybehavior接口和两个实现类,为了方便我就放在一起了。
package behaviour; public interface flybehavior { void fly(); } package behaviour; public class flywithwings implements flybehavior{ @override public void fly() { system.out.println("flywithwings"); } } package behaviour; public class flynoway implements flybehavior { @override public void fly() { system.out.println("i can't fly"); } }
接下来我们就可以测试这只“驯化野鸭”的飞行行为了。
测试当中呢,首先先飞行了一下,当然会展示“驯化野鸭”的默认飞行行为,即“flywithwings”,随后小鸭子不小心受伤了它暂时不能飞行了,我们给它动态地重新设置了飞行行为,最后伤好了,自然又可以飞行了,然后只需要再重新设置就好了~
package test; import behaviour.flynoway; import behaviour.flywithwings; import object.duck; import object.concreteobject.mallardduck; public class test { public static void main(string[] args) { duck mallard = new mallardduck(); mallard.performfly(); system.out.println("------------------------------"); system.out.println("我不小心受伤了,这段时间我不能飞行了。。。"); system.out.println("------------------------------"); mallard.setflybehavior(new flynoway()); mallard.performfly(); system.out.println("------------------------------"); system.out.println("我有恢复健康了~"); system.out.println("------------------------------"); mallard.setflybehavior(new flywithwings()); mallard.performfly(); } }
看,说的没错吧。。。。
这基本就是我对策略模式的学习总结吧,这个案例也是《head first设计模式》中的,鸭子(各种鸭子), 各种行为(行为1[具体的行为1,具体的行为2.......],行为2[具体的行为1,具体的行为2.......] .......),鸭子有很多种类,有的特殊的鸭子肯定有特殊行为,而行为可能一时也不好总结,谁知道哪天又会横空出世一种行为呢? 鸭子可以通过策略模式,动态地绑定行为,而新增行为,只需要再写个接口,随后再duck类中加上对应的类型的变量就好了。(我还是再写一下吧,看看自己是不是真的理解了。。)
举例
本来想继续扩展鸭子,但是看到书上有另一案例。。
接下来就是粘贴代码了,粗略的写了一下,大概情节就是,角色: 有公主和骑士...,有两种行为,使用武器,跳舞,默认公主不会跳舞,和用匕首刺杀,而骑士可以用宝剑刺杀,没有跳舞行为。随后公主学了跳舞,变有了快乐地跳起了舞~
两种行为:
package behaviour; /** * 跳舞 * * @author deepsleeping * */ public interface dancebehavior { void dance(); } package behaviour; /** * 可以使用武器 * @author deepsleeping * */ public interface weaponbehavior { void useweapon(); }
两种行为对应的具体实现(表现):
package behaviour; /** * 快乐地跳舞 * * @author deepsleeping * */ public class dancehappy implements dancebehavior { @override public void dance() { system.out.println("快乐地跳舞!"); } } package behaviour; /** * 不可能跳舞 * * @author deepsleeping * */ public class dancenoway implements dancebehavior { @override public void dance() { system.out.println("我怎么可能会跳舞!"); } } package behaviour; /** * 使用匕首 * * @author deepsleeping * */ public class knifebehavior implements weaponbehavior { @override public void useweapon() { system.out.println("-使用匕首刺杀-"); } } package behaviour; /** * 使用宝剑 * * @author deepsleeping * */ public class swordbehavior implements weaponbehavior { @override public void useweapon() { system.out.println("-使用宝剑刺杀-"); } }
角色,以及角色下的 公主、骑士
package object; import behaviour.dancebehavior; import behaviour.weaponbehavior; /** * 角色 * * @author deepsleeping * */ public abstract class character { weaponbehavior wb; dancebehavior db; public void setdb(dancebehavior db) { this.db = db; } public void setwb(weaponbehavior wb) { this.wb = wb; } /** *战斗 */ public void fight() { wb.useweapon(); } /** * 跳舞 */ public void dance() { db.dance(); } } package object; import behaviour.dancenoway; import behaviour.swordbehavior; /** * 骑士 * * @author deepsleeping * */ public class knight extends character { public knight() { // 默认骑士是用宝剑的 wb = new swordbehavior(); } } package object; import behaviour.dancenoway; import behaviour.knifebehavior; /** * 公主 * @author deepsleeping * */ public class queen extends character{ public queen(){ //默认公主是用匕首的 wb = new knifebehavior(); //默认公主不会跳舞 db = new dancenoway(); } }
开始测试~
package test; import behaviour.dancehappy; import behaviour.swordbehavior; import object.character; import object.knight; import object.queen; public class test { public static void main(string[] args) { character knight = new knight(); character queen = new queen(); // 骑士去刺杀 knight.fight(); // 公主去刺杀 queen.fight(); // 公主换成用宝剑刺杀 queen.setwb(new swordbehavior()); queen.fight(); system.out.println("--------------------"); queen.dance(); // 公主学会了跳舞 queen.setdb(new dancehappy()); queen.dance(); } }
总结
总结下几个不错的设计原则:
1.找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
2.针对接口编程,而不是针对实现编程。
3.多用组合,少用继承
好了 ,策略模式就认识到这了,通过学习,我也算是对策略模式有了初步的认识吧,中间写着写着感觉好像装饰者模式啊,哈哈,又有点蒙了,继续学习吧。。。
参考材料:《head first设计模式》
上一篇: PHP默认安装产生系统漏洞
下一篇: 正则表达式语法