策略模式

  1. /*
  2.  * 关于策略模式
  3.  * 策略模式的作用是为了将一堆各种不同的算法或策略用相同接口表示出来,在使用是利用接口来实现调用
  4.  * 下面是<深入浅出设计模式>中一个简单例子,自己按自己想法写成,如有问题,请提出意见
  5.  * Duck是一个抽象基类,需要其他各种不同类型的鸭子来继承(例如有飞行鸭?,quake翻译为震动鸭???,还有其他各种鸭子)
  6.  *这时候,其他鸭子就继承基类鸭,而鸭有自己行为,飞行(不管怎么飞),震动(不管怎么震动,反正会就行),而且飞行震动还有各种组合
  7.  *有wing飞行,没wing飞行,会quake的飞行,不会quake的鸭诸如此类,还有很多很多行为,各种行为又有个中不同方式
  8.  *这时,可以利用策略模式实现
  9.  *策略模式个人理解共同接口,具体实现方式各自解决
  10.  *下面程序中:
  11.  *FlyBehavior 是一个接口,具体怎么飞的行为有几种:FlyWithoutWing  FlyWithWing诸如此类
  12.  *QuakeBehavior 是另一种行为的接口,具体怎么quake有:CantQuake,......
  13.  *还可以用更多其他扩展接口,只要认为一鸭他有的行为,做出接口,然后具体实现的时候,你家的鸭,我家的鸭怎么飞,怎么叫,不管,只要用接口就好了
  14.  *
  15.  *注意Duck里两个FlyBehavior,QuakeBehavior变量,这两个变量可以在运行时实施变化,这是利用了“组合而不是继承”,如果使用了继承,
  16.  *每次继承时都需要new一个对象出来,想变的时候就不能了变了,而在内部设为变量的话,利用setxxxx函数可以运行时改变!!
  17.  *
  18.  * FlyWithWingCantQuakeDuck是继承duck的,初始化时塞进了两个行为变量,fly,quake,然后在运行时变化了!~!
  19.  * 
  20.  * 在以后添加各种策略时,直接new一行为,然后插入就ok了
  21.  * 
  22.  * 粗略谈下,有所不妥,望指导
  23.  * 
  24.  * 待续...
  25.  */
  26. package strategy_p;
  27. public class TestStrategy_P {
  28.     /**
  29.      * @param args
  30.      */
  31.     public static void main(String[] args) {
  32.         // TODO 自动生成方法存根
  33.         FlyBehavior fly = new FlyWithWing();
  34.         QuakeBehavior quake = new CantQuake();
  35.         
  36.         Duck duck1 = new FlyWithWingCantQuakeDuck(fly,quake);
  37.         
  38.         duck1.fly();
  39.         duck1.quake();
  40.         
  41.         duck1.SetFlyBehavior(new FlyWithoutWing());
  42.         duck1.fly();
  43.         duck1.quake();
  44.         
  45.     }
  46. }
  47. //Duck.java
  48. package strategy_p;
  49. abstract class Duck {       //抽象类
  50.     
  51.     FlyBehavior duck_fly;
  52.     QuakeBehavior duck_quake;
  53.     
  54.     Duck(FlyBehavior fd,QuakeBehavior qd){
  55.         duck_fly = fd;
  56.         duck_quake = qd;
  57.     }
  58.     
  59.     void SetFlyBehavior(FlyBehavior fd){
  60.         duck_fly = fd;
  61.     }
  62.     
  63.     void SetQuakeBehavior(QuakeBehavior qd){
  64.         duck_quake = qd;
  65.     }
  66.     void fly(){
  67.         duck_fly.Fly();
  68.     }
  69.     
  70.     void quake(){
  71.         duck_quake.Quake();
  72.     }
  73. }
  74. //FlyBehavior.java 
  75. package strategy_p;
  76. interface FlyBehavior {
  77.     void Fly();
  78. }
  79. //QuakeBehavior.java 
  80. package strategy_p;
  81. interface QuakeBehavior {
  82.     
  83.     void Quake();
  84. }
  85. //FlyWithoutWing.java 
  86. package strategy_p;
  87. class FlyWithoutWing implements FlyBehavior{
  88.     
  89.     public void Fly(){
  90.         System.out.println("i fly without wing");
  91.     }
  92. }
  93. //FlyWithWing .java
  94. package strategy_p;
  95. class FlyWithWing implements FlyBehavior {
  96.     
  97.     public void Fly(){
  98.         
  99.         System.out.println("i fly with wing");
  100.     }
  101. }
  102. //CantQuake.java
  103. package strategy_p;
  104. class CantQuake implements QuakeBehavior{
  105.     
  106.     public void Quake(){
  107.         System.out.println("I Cant Quake");
  108.     }
  109.     
  110. }
  111. //FlyWithWingCantQuakeDuck .java
  112. package strategy_p;
  113. class FlyWithWingCantQuakeDuck extends Duck{
  114.     
  115.     FlyWithWingCantQuakeDuck(FlyBehavior f1,QuakeBehavior q1){
  116.         
  117.         super(f1,q1);       
  118.     }
  119. }
阅读更多
个人分类: 设计模式
上一篇命令模式
下一篇观察者模式
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭