/**
 * 支付策略接口
 *
 */
public interface PayStrategy {
    boolean pay(int paymentAmount);
    void collectPaymentDetails();
}

/**
 * 微信支付
 *
 */
public class WeixinPay implements PayStrategy {
    @Override
    public void collectPaymentDetails() {
        System.out.print("使用微信支付");
    }

    @Override
    public boolean pay(int paymentAmount) {
        System.out.print("使用微信支付");
    }
}

/**
 * 支付宝支付
 *
 */
public class AliPay implements PayStrategy {
    @Override
    public void collectPaymentDetails() {
        System.out.print("使用支付宝支付");
    }

    @Override
    public boolean pay(int paymentAmount) {
        System.out.print("使用支付宝支付");
    }
}

/**
 * 订单类
 *
 */
public class Order {
    public void processOrder(PayStrategy strategy) {
        strategy.collectPaymentDetails();
    }
}

/**
 * 客户端
 *
 */
public class Client {
    private static boolean flag = true;
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private static Order order = new Order();
    private static PayStrategy strategy;

    public static void main(String[] args) throws IOException {
        while (flag) {
            if (strategy == null) {
                System.out.println("请选择支付方式：" + "\n" +
                        "1 - 微信" + "\n" +
                        "2 - 支付宝");
                String paymentMethod = reader.readLine();
                if (paymentMethod.equals("1")) {
                    strategy = new WeixinPay();
                } else {
                    strategy = new AliPay();
                }
                order.processOrder(strategy);
				flag = false;
                // 继续处理剩下的业务逻辑
                // ......
            }
        }
    }
}

Go

package main

import "fmt"

/**
 * 缓存淘汰策略接口
 *
 */
type EvictionAlgo interface {
    evict(c *Cache)
}

/**
 * 具体策略：FIFO
 *
 */
type Fifo struct {
}

func (l *Fifo) evict(c *Cache) {
    fmt.Println("FIFO策略")
}

/**
 * 具体策略：LFU
 *
 */
type Lfu struct {
}

func (l *Lfu) evict(c *Cache) {
    fmt.Println("LFU策略")
}

/**
 * 处理缓存
 *
 */
type Cache struct {
    storage      map[string]string
    evictionAlgo EvictionAlgo
    capacity     int
    maxCapacity  int
}

func initCache(e EvictionAlgo) *Cache {
    storage := make(map[string]string)
    return &Cache{
        storage:      storage,
        evictionAlgo: e,
        capacity:     0,
        maxCapacity:  2,
    }
}

func (c *Cache) setEvictionAlgo(e EvictionAlgo) {
    c.evictionAlgo = e
}

func (c *Cache) add(key, value string) {
    if c.capacity == c.maxCapacity {
        c.evict()
    }
    c.capacity++
    c.storage[key] = value
}

func (c *Cache) get(key string) {
    delete(c.storage, key)
}

func (c *Cache) evict() {
    c.evictionAlgo.evict(c)
    c.capacity--
}

/**
 * 客户端
 *
 */
func main() {
    lfu := &Lfu{}
    cache := initCache(lfu)
    cache.add("a", "1")
    cache.add("b", "2")
    cache.add("c", "3")

    lru := &Lru{}
    cache.setEvictionAlgo(lru)
    cache.add("d", "4")

    fifo := &Fifo{}
    cache.setEvictionAlgo(fifo)
    cache.add("e", "5")
}

适用场景

如果在系统中大多数类之间的区别仅在于行为，就可以使用策略模式动态地让一个对象在许多行为中选择一种。
当有诸多的判断条件，而每一种条件都对应一种操作时，可以使用策略模式来封装这些不同的操作。
如果希望将客户端与复杂的算法条件解耦，可以使用策略模式来提高算法的保密性与安全性。
如果算法在上下文的逻辑中不重要，可以使用策略模式将业务逻辑与算法实现隔离开来。

优缺点

策略模式的优点。
- 可以在不修改原有系统的基础上增加新的行为，符合开闭原则。
- 可将算法的实现和使用算法的代码隔离。
- 可以使用组合来代替继承。
策略模式的缺点。
- 如果算法极少改变，那么没有任何理由引入新的类和接口，该模式只会让程序变得复杂。
- 客户端必须知晓策略间的不同并选择合适的策略，这是另一种耦合。