设计模式——策略模式( Strategy Pattern )

写代码超过千行，自定义类10个以上，往往写着写着就觉的乱，最终决定抽空补习下设计模式方面的知识。本来AS3出了本关于设计模式的书的，国人也翻译了。我同事也早早买了一本，但前些天我借来看了几页，翻译的太不负责任了，还不如看E文来的实在。（AS3设计模式本身写的不错，翻译的太差了）。

这里介绍一本四人组的经典之作《Head First 设计模式》。用JAVA写的，不过不懂JAVA也能看懂。JAVA,C++的经典书籍真是太多了，但AS3的经典书籍屈指可数……    看完一篇后就用AS3写一遍，算是做下学习笔记吧~~

 第一篇：策略模式

                定义了算法族，分别封装起来，让它们之间可以互相替换， 此模式让算法的变化独立于使用算法的客户。

 继承的弊端：在有些情况下，父类的东西会成为子类的一个累赘。文中说的一个情况具体是这样：

图一：

这是原来的框架结构，所有的子Duck继承与Duck类，Duck类有三个方法，具体类具体实现。现在的问题是：让鸭子飞起来，就是给鸭子添加一个fly()方法  下图是个错误的思路：

在父类Duck中添加了一个fly()方法，但是不应该飞的鸭子也跟着飞了起来。具体的去看看原文吧。

设计原则：

以下是用策略模式写的DUCK，主要是要理解多态的含义：

整体结构是这样的：父类:Duck    子类：WoodDuck   MalladDuck 

                                    接口:IFly  IQuack

                                    行为类:NoFly Fly  NoQuack Quack RocketFly  用于实现IFly与IQuack两接口

 

具体代码：

        接口：

1. package {
2.     public  interface  IFly
3.     {
4.         function fly():void;
5.     }
6. }

1. package {
2.     public  interface  IQuack
3.     {
4.         function quack():void;
5.     }
6. }

父类Duck：

1. package
2. {
3.     public class  Duck
4.     {
5.         protected var flyBehavior:IFly;//飞 行为接口
6.         protected var quackBehavior:IQuack;//叫 行为接口
7.         public function Duck()
8.         { }
9.         public function performFly():void
10.         {
11.             flyBehavior.fly();
12.         }
13.         public function performQuack():void
14.         {
15.             quackBehavior.quack();
16.         }
17.         public function display():void    //鸭子外观
18.         {
19.             //
20.         }
21.         //接口的动态实现
22.         public function setFlyBehavior(value:IFly):void 
23.         {
24.             flyBehavior = value;
25.         }
26.         public function setQuackBehavior(value:IQuack):void 
27.         {
28.             quackBehavior = value;
29.         }
30.         
31.     }
32. }

木头鸭  不会飞 不会叫

1. package
2. {
3.     public class WoodDuck extends Duck
4.     {
5.         public function WoodDuck()
6.         {
7.             flyBehavior = new NoFly();
8.             quackBehavior = new NoQuack();
9.         }
10.     }
11. }

野鸭  会飞 会叫

1. package
2. {
3.     public class MallardDuck extends Duck
4.     {
5.         public function MallardDuck()
6.         {
7.             flyBehavior = new Fly();
8.             quackBehavior = new Quack();
9.         }
10.     }
11. }

实现接口的具体类：

普通飞与普通叫：

1. package
2. {
3.     public  class Fly implements IFly
4.     {
5.         public function fly():void
6.         {
7.             trace("FLY    FLY  ");
8.         }
9.     }
10. }

1. package
2. {
3.     public class Quack implements IQuack
4.     {
5.         public function quack():void
6.         {
7.             trace("QUACK    QUACK");
8.         }
9.     }
10. }

不会飞 不会叫  和一个用来测试的坐着火箭飞：

1. package
2. {
3.     public class NoFly implements IFly
4.     {
5.         public function fly():void
6.         {
7.             trace("NoFly   ");
8.         }
9.     }
10. }

1. package
2. {
3.     public class NoQuack implements IQuack
4.     {
5.         public function quack():void
6.         {
7.             trace("No Quack");
8.         }
9.     }
10. }

1. package
2. {
3.     public class RocketFly implements IFly
4.     {
5.         public function fly():void
6.         {
7.             trace("坐着火箭飞");
8.         }
9.     }
10. }

文档类：

1. package
2. {
3.         import flash.display.Sprite;
4.         public class  Main extends Sprite
5.         {
6.             public var aDuck:WoodDuck;
7.             public var bDuck:MallardDuck;
8.             public function Main()
9.             {
10.                 bDuck = new MallardDuck();
11.                  bDuck.performFly();
12.                  bDuck.performQuack();
13.                 trace("------------------------------------");
14.                 aDuck = new WoodDuck();
15.                 aDuck.performFly();
16.                 aDuck.performQuack();
17.                 trace("--------------动态绑定-----------------------");
18.                aDuck.setFlyBehavior(new RocketFly());
19.                aDuck.performFly();
20.             }
21.         }
22. }

输出：

FLY    FLY 
QUACK    QUACK
------------------------------------
NoFly  
No Quack
--------------动态绑定-----------------------
坐着火箭飞

----------------------------------------------------------------------------------分割线----------------------------------------------------

策略模式主要是把易于变化的部分分别封装起来，而实现他们相互之间可以替换主要是依靠向下转化。

书中的例子依然有些不便之处 ，就是Duck 并没有完全从父类Duck中拿出来 ，继承它的子类依然继承着这两个成员变量：quackBehavior和flyBehavior。具体怎么拿出来还是要继续看下哦，看到后补上~~