设计模式随笔-策略模式

策略模式笔记

最近看完了一本叫《Head First 设计模式》的书，学习到了一些关于基础的模式，也在这记录一下自己的学习心得，写此笔记是希望在现实项目中想用某种模式，但是又模糊不清时，能够方便查看笔记。

Duck问题

首先看以下设计：

现在产品经理要改需求了，需要让鸭子会飞。于是咋们很容易想到在Duck对象里加一个会飞的方法。于是乎有了以下的设计：

但是可怕的事情发生了。因为继承Duck的子类有一个叫“橡皮鸭”的鸭子品种，但是它现在居然具备了会飞的功能。于是乎想到了在橡皮鸭这个子类里面覆盖 fly()方法，不做任何事情。如下图所示：

如果是这样设计，以后在要加一个“木头鸭”，即不会飞，也不会叫。这样又要覆盖quack 和 fly 方法了。我们意识到可能继承不是一种好的设计方法，如果鸭子有加入了一个新功能，可能又要让自己检查所有的子类，这将会是一场噩梦。于是，我们可能想到用接口来实现设计了。

---

用接口来设计DUCK

我们可以把鸭子经常改变的行为：fly、quack等行为取出，放进一个接口中。

不管当初软件设计的多好，一段时间之后，总是需要成长和改变，
否则软件就会“死亡”

现在我们定义两个接口 FlyBehavior 和 QuackBehavior 这两个定义了鸭子飞和喊得行为接口。并且列出继承这些行为接口的实现类。如下图所示：

这样的设计不但可以让鸭子类复用，而且还能与鸭子类分离。而且我们增加一些行为类，也不会影响到其他鸭子类了。
这个关键的设计在于讲飞行和呱呱的动作都“委托”别人处理，而不是使用定义在Duck类的呱呱和飞行方法了。
Duck类如下图所示：

具体鸭子代码如下：

public abstract class Duck {
     
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public Duck(){
    }

    public abstract void display();

    public void performFly(){
        flyBehavior.fly();
    }

    public void performQuack(){
        quackBehavior.quack();
    }

    public void swim(){
        System.out.println("All ducks float, even decoys!");
    }

    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
}

public class MallardDuck extends Duck {
     
    public MallardDuck() {
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

    @Override
    public void display() {
        System.out.println("I'm a real Mallard duck");
    }

}

具体Fly 和 Quack行为代码如下：

public interface FlyBehavior {
     
    //飞行行为
    public void fly();
}

public class FlyNoWay implements FlyBehavior {
     
    @Override
    public void fly() {
        System.out.println("I' can't fly");
    }
}

public class FlyRocktPowered implements FlyBehavior {
     
    @Override
    public void fly() {
        System.out.println("I'm flying with a rocket!");
    }
}

public interface QuackBehavior {
     
    //定义鸭子叫的行为
    public void quack();
}

public class Quack implements QuackBehavior {
     
    @Override
    public void quack() {
        System.out.println("Quack");
    }
}

public class Squeak implements QuackBehavior {
     
    @Override
    public void quack() {
        System.out.println("Squeak");
    }
}

public class MuteQuack implements QuackBehavior {
     
    @Override
    public void quack() {
        System.out.println("<< Silence >>");
    }
}

运行代码及运行结果：

public class DuckTest extends TestCase{
     

    public void testMallardDuck(){
        Duck mallard = new MallardDuck();
        mallard.performFly();
        mallard.performQuack();
    }
}
//运行结果
----------------------
I'm flying!
Quack
----------------------

---

结论

1.找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起

2.针对接口编程，而不是针对实现编程

3.多用组合，少用继承

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