设计模式-用支付宝还是用微信-策略模式

在同样的条件（输入）用不同的策略（往往是牺牲时间或者牺牲空间的算法的变体）完成一件相同的任务，这就是策略模式的描述，与状态模式（在对象的属性的改变的时候，行为也会发生变化）最大的不同在于应用的场景更加纯粹，耦合程度更低，也是最常用的设计模式之一．

最简单的场景

设想你在超市里刚刚买完东西，需要支付购物车里的一堆东西，打开手机，微信和支付宝并列出现，用微信还是用支付宝呢？

无论是微信还是支付宝都是一种支付的方式，只是想用它完成支付的功能，用完就收回了，下次的支付跟这次也没有任何关系．这就是策略模式的最简单的场景．

下面用java 代码来实现用支付宝还是微信支付的策略：

package com.lucien.strategy;

public interface PaymentStrategy {
    void pay(int money);
}

package com.lucien.strategy;

public class AliPaymentStategy implements PaymentStrategy {
    @Override
    public void pay(int money) {
        System.out.println("spend " + money + " via ali payment");
    }
}

package com.lucien.strategy;

public class WechatPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(int money) {
        System.out.println("spend " + money + " via wechat payment");
    }
}

以上可以看到　AliPaymentStategy　和　WechatPaymentStrategy　分别实现了　PaymentStrategy　，这说明两者具有同样的作用，可以互相替换，都只是一种支付方式．

当然也少不了购物车和物品：

package com.lucien.strategy;

import java.util.ArrayList;
import java.util.List;

public class ShoppingCart {

    List<ShoppingItem> items = new ArrayList<>();

    public void addItem(ShoppingItem item) {
        if (item != null) {
            items.add(item);
        }
    }

    public void payOff(PaymentStrategy strategy) {
        int totalCost = 0;
        for (ShoppingItem item : items) {
            totalCost += item.getPrice();
        }
        strategy.pay(totalCost);
    }
}

package com.lucien.strategy;

public class ShoppingItem {
    private String name;
    private int price;

    ShoppingItem(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "ShoppingItem{" +
                "name='" + name + '\'' +
                ", price='" + price + '\'' +
                '}';
    }
}

全部的代码UML图如下所示：

类图关系.png

最终的客户端的测试类如下：

package com.lucien.strategy;

public class ClientTest {

    public static void main(String[] args) {
        // write your code here
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(new ShoppingItem("apple", 5));
        cart.addItem(new ShoppingItem("banana", 5));
        cart.addItem(new ShoppingItem("tissue", 5));

        cart.payOff(new WechatPaymentStrategy());

        cart.payOff(new AliPaymentStategy());
    }
}

输出结果：

spend 15 via wechat payment
spend 15 via ali payment

也可以参考java原生支持的类

Collections.sort()
Arrays.sort()

同样是很经典的策略模式的实现．

重点注意：

• 尽量不要让策略类被使用类持有，减少耦合程度，Collections.sort()
  Arrays.sort()就是最好的例子，我们只想用策略来完成一个任务．
• 如果被使用类持有，通常情况下可能是类的一个特定行为，或者回调，但是这跟状态模式还是在理解上还是有很大不同．
• 尽管策略模式和状态模式代码上很像，但是概念理解是不一样的，状态模式之间可能有顺序上的关系，需要指定状态变化的规则．

其实代码上可能会有细微的差别，我们不必过于纠缠，但是理解上一定要搞清楚．因为这代表最初设计时的思想和核心．