设计模式——策略模式（附代码示例）

一. 传统方式

以统计不同鸭子信息为例

1. 传统方式解决

        抽象一个Duck类，不同鸭子继承Duck，如果有相同行为就默认继承，有不同行为就重写

类图

        

代码实现

        Duck抽象类

public abstract class Duck {
    public Duck() {

    }

    public abstract void display();

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

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

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

        WildDuck类，表示野鸭 

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

         PekingDuck类，表示北京鸭

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

    @Override
    public void fly() {
        System.out.println("北京鸭不能飞");
    }
}

         ToyDuck类，表示玩具鸭

public 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("玩具鸭不会飞");
    }
}

2. 传统方式存在问题

        所有鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。其实是继承带来的问题，对类的局部改动，尤其超类的局部改动，会影响其他部分，会有溢出效应。我们可以通过覆盖fly方法来解决，但是如果我们有一个玩具鸭子ToyDuck，这样就需要ToyDuck去覆盖Duck的所有实现的方法。故引出策略模式。

二. 策略模式

1. 概念

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

        设计原则：1. 把变化的代码从不变的代码中分离出来 

                          2. 针对接口编程而不是具体类(定义了策略接口)

                          3. 多用组合/聚合，少用继承(客户通过组合方式使用策略)

2. 设计模式原理类图

        客户context有成员变量strategy或者其他的策略接口，至于需要使用到哪个策略，我们可以在构造器中指定

3. 代码示例 

类图

        不是所有鸭子的叫声都一样以及都会飞，所以将叫声和飞翔设为不同策略

        FlyBehavior接口，策略接口

public interface FlyBehavior {
    void fly(); //子类具体实现
}

        NoFly类，实现FlyBehavior接口，表示不会飞

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

      GoodFly类，实现FlyBehavior接口，表示飞得很好

public class GoodFly implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("飞翔技术高超");
    }
}

        BadFly类，实现FlyBehavior接口，表示飞得糟糕

public class BadFly implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("飞翔技术糟糕");
    }
}

         Duck抽象类，聚合策略接口FlyBehavior，并可动态改变

public abstract class Duck {
    //策略接口
    FlyBehavior flyBehavior;

    public Duck() {

    }

    public abstract void display();

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

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

    public void fly(){
        if(flyBehavior!=null){
            flyBehavior.fly();
        }
    }

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

          WildDuck类，表示野鸭，通过构造器定义飞行策略为飞得很好

public class WildDuck extends Duck {

    public WildDuck() {
        flyBehavior = new GoodFly();
    }

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

         ToyDuck类，表示玩具鸭，通过构造器定义飞行策略为不会飞

public class ToyDuck extends Duck {

    public ToyDuck() {
        flyBehavior = new NoFly();
    }

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

    @Override
    public void quack() {
        System.out.println("玩具鸭不能叫");
    }

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

}

         PekingDuck类，表示北京鸭，通过构造器定义飞行策略为飞得糟糕

public class PekingDuck extends Duck {

    public PekingDuck() {
        flyBehavior = new BadFly();
    }

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

        Client类，展示不同鸭子的飞行策略 

public class Client {
    public static void main(String[] args) {
        System.out.println("========野鸭============");
        WildDuck wildDuck = new WildDuck();
        wildDuck.fly();
        System.out.println("========玩具鸭============");
        ToyDuck toyDuck = new ToyDuck();
        toyDuck.fly();
        System.out.println("========北京鸭============");
        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.fly();
        System.out.println("========动态改变，北京鸭============");
        pekingDuck.setFlyBehavior(new NoFly());
        pekingDuck.fly();
    }
}

输出结果

三. 总结

1. 优点

        策略模式体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略(或者行为)即可，避免了使用多重转移语句(if..else if...else)

        策略模式提供了可以替换继承关系的办法：将算法封装在独立的Strategy类中使得可以独立于其Context改变它，使它易于切换、易于理解、易于扩展

2. 不足

        每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大

3. 关键

        策略模式的关键是分析项目中变化部分与不变部分

        策略模式的核心思想是多用组合/聚合少用继承；用行为类组合，而不是行为的继承。