GoF 行为型 策略模式

策略模式的定义

定义一系列的算法，把它们一个个封装起来，并且使他们可相互替换。本模式使得算法可独立于使用它的客户而变化。

策略模式的本质

分离算法，选择实现。

策略模式的优缺点

缺点

• 客户必须了解每种策略的不同。
• 增加了对象数目
• 只适合扁平的算法结构。如果需要嵌套使用多个算法可以考虑策略模式、变形的职责连、AOP等

示例1

/**
 * 策略，定义算法的接口
 */
public interface Strategy {

    /**
     * 某个算法的接口，可以有传入参数也可以有返回值
     */
    void algorithmInterface();
    
}

/**
 * 实现具体的算法
 */
public class ConcreteStrategyA implements Strategy {
    @Override
    public void algorithmInterface() {
        //具体的算法实现
    }
}

/**
 * 实现具体的算法
 */
public class ConcreteStrategyB implements Strategy {
    @Override
    public void algorithmInterface() {
        //具体的算法实现
    }
}

/**
 * 实现具体的算法
 */
public class ConcreteStrategyC implements Strategy {
    @Override
    public void algorithmInterface() {
        //具体的算法实现
    }
}

/**
 * 上下文对象，通常会持有一个具体的策略实现
 */
public class Context {

    /**持有一个具体的策略对象*/
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void contextInterface() {
        strategy.algorithmInterface();
    }
}

示例2

可以看到，没有上下文策略模式就是普通的接口和实现了，但没有上下文尤其是需要提供一些公共功能、或者存储状态的时候，客户端会变得复杂。

/**
 * 策略，定义计算报价算法的接口
 */
public interface Strategy {
    /**
     * 计算应报的价格
     * @param goodsPrice
     * @return
     */
    double calcPrice(double goodsPrice);
}

/**
 * 具体算法实现，为新客户或者是普通客户计算应报的价格
 */
public class NormalCustomerStrategy implements Strategy {
    @Override
    public double calcPrice(double goodsPrice) {
        System.out.println("对于新客户或者普通客户，没有折扣");
        return goodsPrice;
    }
}

/**
 * 具体算法实现，为新客户或者是普通客户计算应报的价格
 */
public class OldCustomerStrategy implements Strategy {
    @Override
    public double calcPrice(double goodsPrice) {
        System.out.println("对于老客户，折扣5%");
        return goodsPrice * (1 - 0.05);
    }
}

/**
 * 具体算法实现，为大客户计算应报的价格
 */
public class LargeCustomerStrategy implements Strategy {
    @Override
    public double calcPrice(double goodsPrice) {
        System.out.println("对于老客户，折扣10%");
        return goodsPrice * (1 - 0.1);
    }
}

/**
 * 价格管理，主要完成计算向客户所报价格的功能
 */
public class Price {

    /**持有一个具体的策略对象*/
    private Strategy strategy = null;


    public Price(Strategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 报价，计算对客户的报价
     * @param goodsPrice
     * @return
     */
    public double quote(double goodsPrice) {
        return this.strategy.calcPrice(goodsPrice);
    }
}

public class TestClient {
    public static void main(String[] args) {
        Strategy strategy = new LargeCustomerStrategy();
        Price ctx = new Price(strategy);
        double quote = ctx.quote(1000);
        System.out.println("向客户报价："+quote);
    }
}

示例3

/**
 * 支付工资的策略接口，公司有多种支付工资的算法
 * 比如，现金、银行卡、现金价股票、现金加期权、美元支付等
 */
public interface PaymentStrategy {

    /**
     * 公司给某人真正支付工资
     * @param ctx 支付工资的上下文，里面包含算法需要的数据
     */
    void pay(PaymentContext ctx);
}

/**
 * 人民币现金支付
 */
public class RMBCash implements PaymentStrategy {
    @Override
    public void pay(PaymentContext ctx) {
        System.out.println("现在给"+ctx.getUserName()+
                ",人民币现金支付"+ctx.getMoney()+"元");
    }
}

/**
 * 美元现金支付
 */
public class DollarCash implements PaymentStrategy{
    @Override
    public void pay(PaymentContext ctx) {
        System.out.println("现在给"+ctx.getUserName()+
                ",美元现金支付"+ctx.getMoney()+"元");
    }
}

/**
 * 支付工资的上下文，每个人的工资不同，支付工资也不同
 */
public class PaymentContext {

    /**应被支付工资的人员，简单点用姓名来代替*/
    private String userName = null;

    /**应该被支付的工资金额*/
    private double money = 0.0;

    /**支付工资的方式的策略接口*/
    private PaymentStrategy strategy = null;

    public PaymentContext(String userName, double money, PaymentStrategy strategy) {
        this.userName = userName;
        this.money = money;
        this.strategy = strategy;
    }

    public String getUserName() {
        return userName;
    }

    public double getMoney() {
        return money;
    }

    /**
     * 立即支付工资
     */
    public void payNow() {
        //使用客户希望的支付策略来支付
        this.strategy.pay(this);
    }
}

public class TestClient {
    public static void main(String[] args) {
        PaymentStrategy strategyRMB = new RMBCash();
        PaymentStrategy strategyDollar = new DollarCash();

        PaymentContext ctx1 = new PaymentContext(
                "小李",5000,strategyRMB);
        ctx1.payNow();
        PaymentContext ctx2 = new PaymentContext(
                "Petter",1000,strategyDollar);
        ctx2.payNow();
    }
}