一、需求引入

        鸭子有不同的种类：绿头鸭、红头鸭、橡皮鸭...，它们都有相同点和不同点，相同点是它们都会游泳，不同点是外观不同，叫法、飞行行为也不一样。其实自然界的很多事物都一样，虽然属于同一大类，有共同点，但是种类细分下去，有不同的表现形式，那么该如何设计这些鸭子呢？

二、初步设计

        首先想到的是继承，将一些相同的行为抽出来，在父类中实现，通过继承父类的方式继承父类的行为，实现代码复用。不同的行为在父类中定义，在子类中实现，类之间的关系图如图1所示：

图1

        代码如下：

图2 图3 图4

        红头鸭（RedHeadDuck）和绿头鸭（MallardDuck）都继承自抽象类Duck，这里有个疑问，为什么用抽象类，可不可以用接口？用抽象类比较好，因为swim()方法是共有的，每个实现类都一样，可以抽到父类中实现，从而代码复用。至于其他行为，由于每个子类的实现都不一样，所以只能在父类中定义，在子类中实现。

        虽然这里实现了共同行为与不同行为的分离，但是还有不完善的地方，万一我加一个鸭子，它和RedHeadDuck一样，也不会飞，那不是要重新编写不会飞的fly()方法吗？显然这里很不灵活。

三、改良设计

        现在我们开始涉及到第一个设计原则：将需要变化的部分取出来封装，而其他部分不受影响。

        通俗点来讲，这里的display()、quack()、fly()行为都是需要变化的，需要抽取出来独立封装成类，但是每种鸭子/甚至每个鸭子的外表display()都是不一样的，所以display()不需要独立抽取出来。对于quack()、fly()这两种行为，因为不同的鸭子行为可能一样，但又不是每种鸭子都一样，添加了一种新的鸭子可能产生一种新的行为，所以需要独立抽取出来。定义行为类，一是为了复用，二是为了解耦，可以在运行时灵活改动。改良后的类图如下（图5）所示：

图5

        从类图中，可以提出几个思考点：不是面向对象吗，为什么行为/动作可以封装成类？此外，行为为什么需要实现接口？

        对于第一个问题，其实面向对象就是将自然界的事物抽象成一个东西，而行为也是一个东西，也有自己的属性与方法，比如：飞行速度、飞行工具都属于飞行行为的属性。

        第二个问题，一是为了遵从面向接口编程的原则，二是可以运用对象多态的特性，简化代码编写，上代码就可以看出其中的奥秘了。

/**

* 鸭子类，抽象类

* 作为所有鸭子的基类，将共同行为抽象出来

* 同时定义共有行为，在子类中不同实现

*/

public abstract class Duck {

    public QuackBehaviorquackBehavior;

    public FlyBehaviorflyBehavior;

    public void swim(){

        System.out.println("所有鸭子都会游泳");

    }

    public abstract void display();

    public void quack(){

        quackBehavior.quack();

    }

    public void fly(){

        flyBehavior.fly();

     }

}

/**

* 绿头鸭，属于鸭子类

* 通过实现父类抽象类的方法，定义其行为

*/

public class MallardDuckextends Duck {

/*

*  默认初始化

*/

    public MallardDuck(){

        this.quackBehavior =new JijiQuack();

        this.flyBehavior =new FlyWithWings();

    }

/*

* 可动态设置叫的行为

*/

    public void setQuack(QuackBehavior quackBehavior){

        this.quackBehavior = quackBehavior;

    }

/*

* 可动态设置飞的行为

*/

    public void setFly(FlyBehavior flyBehavior){

        this.flyBehavior = flyBehavior;

    }

    @Override

    public void display() {

        System.out.println("绿色的头");

    }

}

/**

* 红头鸭，属于鸭子类

* 通过实现父类抽象类的方法，定义其行为

*/

public class RedHeadDuckextends Duck {

/*

*  默认初始化

*/

    public RedHeadDuck(){

        this.quackBehavior =new JijiQuack();

        this.flyBehavior =new FlyWithWings();

    }

/*

* 可动态设置叫的行为

*/

    public void setQuack(QuackBehavior quackBehavior){

        this.quackBehavior = quackBehavior;

    }

/*

* 可动态设置飞的行为

*/

    public void setFly(FlyBehavior flyBehavior){

        this.flyBehavior = flyBehavior;

    }

@Override

    public void display() {

        System.out.println("红色的头");

    }

}

        改进后的代码，比之前简化了很多：

        1、quack()和fly()这两种行为都在Duck中定义了，子类无需重新定义这两种方法。其实这运用了Java的多态特性，在Duck类中定义动作的变量并执行quack()/fly()这两种行为，然后再在子类将具体的动作赋予父类定义的变量，最终运行的时候会自动运行具体动作的方法。这也是面向接口编程的一个好处，可以将接口实现类赋值给该接口声明的变量，运行时虚拟机会自动判断从而执行实现类的方法。

        2、将quack和fly这两种行为抽出来，可以定义任意个子类，所以行为的添加修改就不需要修改原来的代码，而是新建行为类，通过setXXX()方法将行为传进去，可以运行时动态地修改。

三、策略模式

        《Head First设计模式》中这样定义策略模式：策略模式定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法独立于使用此算法的用户。

        通俗来说，就是可以将算法封装起来，然后用的时候使用方法类，从而无需知道其中的实现细节。这样既可以让算法独立于用户，也可以很灵活地添加/修改策略。

四、其他改进方式

        虽然上述代码已经做了很大改进，但是还有不足，在创建行为类实例的时候对实现编程了。最好的做法其实就是不对实现编程。因为可能创建对象的过程可能很复杂，比如FlyWithWings可能需要很多个构造参数，如果每次都手动创建就麻烦了，可以通过工厂模式或者建造者模式构建。