鸭子问题

编写鸭子项目，要求如下

有各种各样的鸭子（如：野鸭、北京鸭、水鸭等），鸭子有各种行为，飞行、叫…
显示鸭子的信息

普通方案：

public abstract class Duck {
    public abstract void display();

    public void quack() {
        System.out.println("嘎嘎叫");
    }

    public void swim() {
        System.out.println("会游泳");
    }

    public void fly() {
        System.out.println("会飞");
    }
}

class WildDuck extends Duck {
    @Override
    public void display() {
        System.out.println("野鸭");
    }
}

class BeijingDuck extends Duck {
    @Override
    public void display() {
        System.out.println("北京鸭");
    }

    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

class ToyDuck extends Duck {
    @Override
    public void display() {
        System.out.println("玩具鸭");
    }

    @Override
    public void quack() {
        System.out.println("不会叫");
    }

    @Override
    public void swim() {
        System.out.println("不会游泳");
    }

    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}
复制代码

普通方案分析

鸭子，都继承Duck类，所以fly让所有的鸭子都会飞，但事实是不是所有的鸭子都会飞的，比如北京鸭，玩具鸭。
上面说的1的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。会有溢出效应。
为了改进1的问题，我们可以通过覆盖fly方法来解决=>覆盖解决。
问题又来了，如果我们一个玩具鸭ToyDuck,这样就需要ToyDuck去覆盖Duck的所有实现的方法=>解决思路策略模式

策略模式基本介绍

策略模式（Strategy Pattern）中，定义了算法簇，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
这算法体现了几个设计模式原则。第一，把变化的代码从不变的代码中分离出来；第二，针对接口编程而不是具体类（定义了策略接口）；第三，多用组合/聚合，少用继承（客户通过组合方式使用策略）。

策略模式原理类图

说明：从图中可看出，客户Context，有成员变量strategy或者其他策略接口。至于需要使用到哪个策略，我们可以在构造器中指定。

策略模式解决鸭子问题

FlyBehavior<=>Stretegy

public interface FlyBehavior {
    void fly();
}

class NoFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

class GoodFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞得更高");
    }
}

class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞得不好");
    }
}
复制代码

duck类<=>Context

public abstract class Duck {
    protected FlyBehavior flyBehavior;

    public Duck() {
    }

    public Duck(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public abstract void display();

    public void quack() {
        System.out.println("嘎嘎叫");
    }

    public void swim() {
        System.out.println("会游泳");
    }

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

class WildDuck extends Duck {
    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("野鸭");
    }
}

class BeijingDuck extends Duck {
    public BeijingDuck() {
        flyBehavior = new BadFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("北京鸭子");
    }
}

class ToyDuck extends Duck {
    public ToyDuck() {
        flyBehavior = new NoFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("玩具鸭");
    }
}
复制代码

public class DuckTest {
    public static void main(String[] args) {
        Duck wildDuck = new WildDuck();
        wildDuck.fly();

        Duck beijingDuck = new BeijingDuck();
        beijingDuck.fly();

        Duck toyDuck = new ToyDuck();
        toyDuck.fly();
    }
}
复制代码