java设计模式学习之策略模式

一、概述

定义：将可变部分从程序中抽象分离成算法接口，在该接口下分别封装一系列算法实现并使他们可以相互替换，从而导致客户端程序独立与算法的改变。
策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

这个模式涉及到三个角色：

• 环境(Context)角色：持有一个Strategy的引用。
• 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
• 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

二、案例代码

假设现在要设计一个鸭子的产品。一个最简单的情况就是设计的鸭子从叫声、外观、飞行能力都是一样的，但是实际情况肯定比这要复杂。比如，红头鸭是红色的用翅膀飞，太空鸭可以在天上飞，大黄鸭不会飞。
1.抽象基类Duck.java

package com.czhappy.designpattern.strategy;

/**
 * 
 * @ClassName: Duck  
 * @Description: 抽象基类  
 * @author chenzheng
 * @date 2017-1-13 上午10:32:37
 */
public abstract class Duck {

    /**
     * 
     * @author chenzheng
     * @since 2017-1-13
     * @Description: 鸣叫
     * @throws
     * void
     */
    public void quack(){
        System.out.println("嘎嘎嘎");
    }

    /**
     * 
     * @author chenzheng
     * @since 2017-1-13
     * @Description: 外观展示
     * @throws
     * void
     */
    public abstract void display();

    private FlyingStrategy flyingStrategy;

    public void setFlyingStrategy(FlyingStrategy flyingStrategy) {
        this.flyingStrategy = flyingStrategy;
    }

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

2.飞行策略接口FlyingStrategy.java

package com.czhappy.designpattern.strategy;

/**
 * 
 * @ClassName: FlyingStrategy  
 * @Description: 飞行策略接口
 * @author chenzheng
 * @date 2017-1-13 上午10:34:01
 */
public interface FlyingStrategy {

    void performFly();

}

3.策略接口的实现类FlyNoWay.java

package com.czhappy.designpattern.strategy.impl;

import com.czhappy.designpattern.strategy.FlyingStrategy;

public class FlyNoWay implements FlyingStrategy{

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

}

4.策略接口的实现类FlyWithRocket.java

package com.czhappy.designpattern.strategy.impl;

import com.czhappy.designpattern.strategy.FlyingStrategy;

public class FlyWithRocket implements FlyingStrategy{

    @Override
    public void performFly() {
        System.out.println("用火箭飞行");
    }

}

5.策略接口的实现类FlyWithWing.java

package com.czhappy.designpattern.strategy.impl;

import com.czhappy.designpattern.strategy.FlyingStrategy;

public class FlyWithWing implements FlyingStrategy{

    @Override
    public void performFly() {
        System.out.println("用翅膀飞");
    }

}

6.大黄鸭BigYellowDuck.java

package com.czhappy.designpattern.strategy;

import com.czhappy.designpattern.strategy.impl.FlyNoWay;

/**
 * 
 * @ClassName: BigYellowDuck  
 * @Description: 大黄鸭 
 * @author chenzheng
 * @date 2017-1-13 上午10:36:01
 */
public class BigYellowDuck extends Duck{



    public BigYellowDuck() {
        super();
        super.setFlyingStrategy(new FlyNoWay());
    }

    @Override
    public void display() {
        System.out.println("我身体很大，全身发黄");
    }

}

7.红头鸭RedHeadDuck.java

package com.czhappy.designpattern.strategy;

import com.czhappy.designpattern.strategy.impl.FlyWithWing;

/**
 * 
 * @ClassName: RedHeadDuck  
 * @Description: 红头鸭
 * @author chenzheng
 * @date 2017-1-13 上午10:35:06
 */
public class RedHeadDuck extends Duck{

    public RedHeadDuck() {
        super();
        super.setFlyingStrategy(new FlyWithWing());
    }

    @Override
    public void display() {
        System.out.println("我的头是红色的");
    }

}

8.太空鸭SpaceDuck.java

package com.czhappy.designpattern.strategy;

import com.czhappy.designpattern.strategy.impl.FlyWithRocket;

/**
 * 
 * @ClassName: SpaceDuck  
 * @Description: 太空鸭
 * @author chenzheng
 * @date 2017-1-13 上午10:34:52
 */
public class SpaceDuck extends Duck{



    public SpaceDuck() {
        super();
        super.setFlyingStrategy(new FlyWithRocket());
    }

    @Override
    public void display() {
        System.out.println("我头戴宇航头盔");
    }

    @Override
    public void quack() {
        System.out.println("我通过无线电与你通信");
    }

}

9.测试类

package com.czhappy.designpattern.strategy;

/**
 * 
 * @ClassName: DuckTest  
 * @Description: 测试类
 * @author chenzheng
 * @date 2017-1-13 上午10:33:43
 */
public class DuckTest {

    public static void main(String[] args) {
        Duck duck1 = new RedHeadDuck();
        Duck duck2 = new BigYellowDuck();
        Duck duck3 = new SpaceDuck();
        duck1.display();
        duck1.quack();
        duck1.fly();
        System.out.println("***************");
        duck2.display();
        duck2.quack();
        duck2.fly();
        System.out.println("***************");
        duck3.display();
        duck3.quack();
        duck3.fly();
    }
}

10.测试结果

三、总结

1.策略模式设计原则：

• 找出应用中需要变化的部分，把他们独立出来，不要和那些不需要变化的代码混在一起；
• 将不变的东西抽象为接口，而变化的部分交给实现去做，具体而言，鸭子飞行的行为是千变万化的，但是鸭子具有飞行行为本身是不变的，我们将不变的部分抽象为飞行策略接口，而将具体的飞行行为交给实现去处理。
• 面向接口编程，而不是面向实现编程。
• 多用组合，少用继承。

2.策略模式的实现：

• 通过分离变化得出策略接口Strategy。
• 编写Strategy的实现类。
• 客户端程序“有一个”Strategy。
• 在客户程序中选择/组装正确的Strategy实现。

3.策略模式的优点：

• 使用了组合，使架构更加灵活。
• 富有弹性，可以较好的应对变化（开闭原则）。
• 更好的代码复用性（相对于继承）。
• 消除了大量的条件语句。

4.策略模式的缺点：

• 客户代码需要了解每个策略实现的细节，不然就会使得实现有可能有不正确的行为。
• 随着时间的推移，策略接口会急剧膨胀，增加了对象的数目。

5.策略模式的适用场景：

• 许多相关的类仅仅是行为差异，将差异的共享分离出来成为一个策略接口，而这些相关的类便成为其算法家族的成员。
• 运行时选取不同的算法变体。
• 通过条件语句在多个分支中选取一个，使用策略模式使得代码更加简洁。