设计模式---策略模式（Strategy Pattern）

目录

 

1、鸭子项目需求

2、传统方案解决

3、传统方案问题分析

4、策略模式基本介绍

5、策略模式的原理类图

6、策略模式解决鸭子问题

7、策略模式在JDK-Arrays中的源码应用

8、注意事项和细节

---

1、鸭子项目需求

1. 有各种鸭子（比如：北京鸭，野鸭，玩具鸭等），鸭子又有各种行为（叫、游泳、飞翔）。
2. 显示鸭子信息

2、传统方案解决

如上图所示，编写抽象父类安排鸭子的公共行为，其它具体的子类继承之。

代码实现：

package com.mayun.study.designpattern.strategy;

/**
 * 鸭子抽象类
 */
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("鸭子会飞");
    }
}

package com.mayun.study.designpattern.strategy;

/**
 * 北京鸭的抽象类
 */
public class PekingDuck extends Duck {
    @Override
    public void display() {
        System.out.println("一只北京鸭子");
    }


    //北京鸭不能飞，因此要重写
    @Override
    public void fly() {
        System.out.println("北京鸭不能飞~~~~");
    }
}

package com.mayun.study.designpattern.strategy;

/**
 * 玩具鸭实现类：父类的方法大部分都要重写
 */
public class ToyDuck extends Duck {
    @Override
    public void display() {
        System.out.println("一只玩具鸭");
    }

    public ToyDuck() {
    }

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

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

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

package com.mayun.study.designpattern.strategy;

/**
 * 野鸭实现类
 */
public class WildDuck extends Duck {
    @Override
    public void display() {
        System.out.println("一只野鸭");

    }
}

3、传统方案问题分析

• 所有鸭子都继承了Duck类，所以fly让所有子类鸭子都会飞了，这是不正确的。
• 这个其实是继承带来的问题，对类局部的改动，尤其超类的局部改动，会影响其它部分，会有益处效应。
• 为了改进这个问题，我们可以通过覆盖fly的方法来解决。
• 随之而来的问题：如果我们有一个玩具鸭ToyDuck,这样搞就需要ToyDuck去覆盖所有的实现方法（因为在超类中的行为，都不符合这个子类），解决方案=》策略模式。

4、策略模式基本介绍

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

5、策略模式的原理类图

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

6、策略模式解决鸭子问题

利用策略模式解决上面的鸭子问题。

策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模式让行为的变化独立与算法的使用者。

代码实现：

package com.mayun.study.designpattern.strategy.improve;

/**
 * 飞翔的策略接口
 */
public interface FlyBehavior {
    /**
     * 飞的行为
     */
    public void fly();
}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 叫的策略接口
 */
public interface QuackBehavior {
    /***
     * 叫的行为
     */
    public void quack();
}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 具体的策略实现类
 */
public class GoodFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {

        System.out.println("飞翔技术高超~~~~");
    }
}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 飞翔策略实现类
 */
public class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞翔技术很差~~~~");
    }
}

package com.mayun.study.designpattern.strategy.improve;
/**
 * 具体的策略实现类
 */
public class NoFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞翔~~~~");
    }
}

 

package com.mayun.study.designpattern.strategy.improve;

/**
 * 嘎嘎叫策略实现类
 */
public class GaGaQuackBehavior implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("嘎嘎叫~~~~");
    }
}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 咯咯叫的策略实现类
 */
public class GeGeQuackBehavior implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("咯咯叫~~~~~~");
    }
}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 不会叫的策略实现类
 */
public class NoQuackBehavior implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("不会叫~~~~");
    }
}

 

package com.mayun.study.designpattern.strategy.improve;

/**
 * 鸭子抽象类
 */
public abstract class Duck {


    //飞翔属性，策略接口
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;//叫属性，策略接口
    //还可以有其它的策略接口。。。。。



    public Duck() {
    }

    /**
     * 显示鸭子信息
     */
    public abstract void display();

    /**
     * 改进叫的方法
     */
    public void quack(){
        if (quackBehavior != null) {
            quackBehavior.quack();
        }
    }
    public  void swim(){
        System.out.println("鸭子会游泳");

    }

    /**
     * 改进飞翔方法
     */
    public void fly(){
        if (flyBehavior != null) {
            flyBehavior.fly();
        }
    }

    public FlyBehavior getFlyBehavior() {
        return flyBehavior;
    }

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

    public QuackBehavior getQuackBehavior() {
        return quackBehavior;
    }

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

package com.mayun.study.designpattern.strategy.improve;

import com.mayun.study.designpattern.strategy.improve.Duck;

/**
 * 玩具鸭实现类：父类的方法大部分都要重写
 */
public class ToyDuck extends Duck {
    @Override
    public void display() {
        System.out.println("一只玩具鸭");
    }

    //通过构造器，初始化拥有的行为
    public ToyDuck() {
        flyBehavior = new NoFlyBehavior();
        quackBehavior = new NoQuackBehavior();
    }

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

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


}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 野鸭实现类
 */
public class WildDuck extends Duck {

    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();//通过构造函数，将飞翔策略初始化
        quackBehavior = new GaGaQuackBehavior();
    }

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

    }
}

package com.mayun.study.designpattern.strategy.improve;



/**
 * 北京鸭的抽象类
 */
public class PekingDuck extends Duck {

    public PekingDuck() {
        flyBehavior = new NoFlyBehavior();//通过构造函数，将飞翔策略初始化
        quackBehavior = new GeGeQuackBehavior();
    }

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



}

package com.mayun.study.designpattern.strategy.improve;

/**
 * 策略模式测试类
 */
public class Client {
    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();
        wildDuck.fly();

        ToyDuck toyDuck = new ToyDuck();
        toyDuck.fly();

        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.fly();
    }
}

7、策略模式在JDK-Arrays中的源码应用

JDK的Arrays的Comparator就使用了策略模式。

8、注意事项和细节

• 策略模式的关键是：分析项目中的不变部分和变化部分。
• 策略模式的核心思想是：多用组合/聚合 少用继承；用行为类组合，而不是行为的继承。更有弹性。
• 体现了“对修改关闭，对扩展开放”的原则，客户端增加行为不用修改原有代码，只要添加一种策略或者行为即可。避免了使用多重转移语句（if..else if...else if ...else...）.
• 提供了可以替换继承关系的方法：策略模式将算法封装在独立的Strategy类中，使得你可以独立于其Context改变它，是他易于切换，易于理解，易于扩展。
• 需要注意的是：每添加一个策略，就要增加一个类，当策略过多时会导致类数目庞大。