head fiest 设计模式第一章

设计准则

面向接口编程而不是实现类

多用组合少用继承

封装将变的分离出来不变的抽出来，很多设计都是有这个演变出来的

第一章讲解的模式是策略模式

作者以设计一个鸭子类的游戏为开端讲解的。Duck类为所有鸭子类的超类，其他类可以继承他

Dack鸭子类里面有多个方法fly  behavior  eat但是有些鸭子是不会飞的这又如何解决。

其一是将fly方法移植出来，用一个专门的接口进行实现。对应的鸭子类继承Duck类implements接口，

但是假设有一百个不同的fly跟其他不同的行为难道要写一百个吗。

能想到的方法是设计fly，behavior and so on接口，然后设计与鸭子类无关的类，这样我们就可以

进行复用。而设计出来的类与鸭子无关。

具体设计以及代码如下：

行为类

public interface Behavior

{

      public void behaviorQueck();

}

行为类的实现类

public class BehaviorImple implements Behavior

{

      @Override

      public void behaviorQueck()

     {

         System. out .println( "吱吱叫" );    

     }

}

飞行接口

public interface Fly

{

      public void flyQuck();

}

实现接口的实现类

public class FlyImpl implements Fly

{

      public void flyQuck()

     {

         System. out .println( "会飞的鸭子" );

         

     }

}

and  so  on的一些类以及实现方法

鸭子类

//有了继承的复用的好处，却没有继承所带来的包袱

public class Duck

{

      // 引用鸭子

      // 利用多态

     Behavior behavior ;

     Fly fly ;

    //鸭子的动作

      public void performQuack()

     {

          behavior .behaviorQueck();

     }

      //鸭子飞

      public void performFly()

     {

          fly .flyQuck();

     }

      public void swin()

     {

         System. out .println( "鸭子游泳啊啊啊" );

     }

}

绿头鸭类

//这里初始化的时候做的还不够完善没有弹性不能动态的改变

public class MalGreenDuck extends Duck

{

      public MalGreenDuck()

     {

          behavior = new BehaviorImple();

          fly = new FlyImpl();

     }

      public void display()

     {

         System. out .println( "这是一个绿头鸭" );

     }

     

}

测试类

public class TestJava

{

      @Test

      public void testDuck()

     {  

         Duck greenDuck = new MalGreenDuck();

          greenDuck .performFly();

          greenDuck .performQuack();

     }

}

上面我们提到了初始化的时候还不够灵活现在那让我们动态的设定行为

第一在Duck类中添加一个方法

鸭子类

public class Duck

{

      // 引用鸭子

      // 利用多态

       //这样的方式利用接口然后就与鸭子类无关，就可以实现复用，只要可以用的鸭子类能利用的类都可以用了。真正实现复用

     Behavior behavior ;

     Fly fly ;

       //添加这样一个方法之后就可以动态的改变鸭子的行为

     public void setFly(FlyImpl fly )

     {

          this . fly = fly ;

     }

     //鸭子的动作

      public void performQuack()

     {

          behavior .behaviorQueck();

     }

      //鸭子飞

      public void performFly()

     {

          fly .flyQuck();

     }

      public void swin()

     {

         System. out .println( "鸭子游泳啊啊啊" );

     }

}

制造一个新的鸭子类

public class ModelDuck extends Duck

{

      public ModelDuck()

     {

          fly = new FlyImpl();

          behavior = new BehaviorImple();

     }

    public void display()

    {

     System. out .println( "im is a modelDuck" );

    }

}

动态的改变

@Test

public void modelDuck()

{

         Duck model = new ModelDuck();

          model .performFly();

          model .performQuack();

          //利用接口动态的改变

          model .setFly( new FlySuperImpl());

          model .performFly();    

     }

}

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