设计模式：策略模式详解与实战

业务场景实战：会员折扣

假设某电商平台推出了多种会员等级，分别为普通用户、VIP、超级 VIP 以及金牌会员。针对不同类别的用户，购买虚拟商品有不同的打折方式。此外，用户每消费一定金额就会增加一个级别。我们可以使用策略模式来处理这种动态变化的计费逻辑。

定义价格计算策略接口

public interface CalPrice {
    Double calPrice(Double originalPrice);
}

具体策略实现

// 普通用户：原价
public class OriginalPrice implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice;
    }
}

// VIP：九折
public class Vip implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice * 0.9;
    }
}

// 超级 VIP：八折
public class SuperVip implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice * 0.8;
    }
}

// 金牌会员：七折
public class GoldVip implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice * 0.7;
    }
}

用户类与策略切换

public class Player {
    private double totalAmount = 0; // 消费总额
    private double amount = 0;      // 单次消费金额
    private CalPrice calPrice = new OriginalPrice(); // 初始策略

    // 购买皮肤，更新总额并可能升级
    public void buy(double amount) {
        this.amount = amount;
        totalAmount += amount;
        
        // 根据总额动态调整策略
        if (totalAmount > 30000) {
            calPrice = new GoldVip();
        } else if (totalAmount > 20000) {
            calPrice = new SuperVip();
        } else if (totalAmount > 10000) {
            calPrice = new Vip();
        }
    }

    // 计算最终支付金额
    public Double calLastAmount() {
        return calPrice.calPrice(amount);
    }

    public double getTotalAmount() {
        return totalAmount;
    }
}

优化方案一：简单工厂模式

虽然上述代码解决了策略切换问题，但 Player 类中包含了大量判断逻辑。我们可以引入简单工厂模式将策略创建逻辑分离出来。

public class CalPriceFactory {
    private CalPriceFactory() {}

    public static CalPrice createCalPrice(Player player) {
        double total = player.getTotalAmount();
        if (total > 30000) {
            return new GoldVip();
        } else if (total > 20000) {
            return new SuperVip();
        } else if (total > 10000) {
            return new Vip();
        } else {
            return new OriginalPrice();
        }
    }
}

缺点：如果增加新的会员等级，工厂类需要修改代码，违反了开闭原则。

优化方案二：注解反射机制

为了解决工厂类频繁修改的问题，可以使用注解配合反射来自动注册和匹配策略。

定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface PriceRegion {
    int max() default Integer.MAX_VALUE;
    int min() default Integer.MIN_VALUE;
}

策略类添加注解

@PriceRegion(max = 10000)
public class OriginalPrice implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice;
    }
}

@PriceRegion(min = 10000, max = 20000)
public class Vip implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice * 0.9;
    }
}

@PriceRegion(min = 20000, max = 30000)
public class SuperVip implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice * 0.8;
    }
}

@PriceRegion(min = 30000)
public class GoldVip implements CalPrice {
    @Override
    public Double calPrice(Double originalPrice) {
        return originalPrice * 0.7;
    }
}

智能工厂实现

public class SmartCalPriceFactory {
    private List<Class<? extends CalPrice>> calPriceList;

    public SmartCalPriceFactory() {
        init();
    }

    private void init() {
        calPriceList = new ArrayList<>();
        // 实际项目中应扫描指定包路径下的类
        // 此处简化演示，手动添加或模拟扫描
        calPriceList.add(OriginalPrice.class);
        calPriceList.add(Vip.class);
        calPriceList.add(SuperVip.class);
        calPriceList.add(GoldVip.class);
    }

    public CalPrice createCalPrice(Player player) {
        for (Class<? extends CalPrice> clazz : calPriceList) {
            PriceRegion region = clazz.getAnnotation(PriceRegion.class);
            if (region != null) {
                double total = player.getTotalAmount();
                if (total >= region.min() && total <= region.max()) {
                    try {
                        return clazz.getDeclaredConstructor().newInstance();
                    } catch (Exception e) {
                        throw new RuntimeException("策略实例化失败", e);
                    }
                }
            }
        }
        throw new RuntimeException("未找到匹配的策略");
    }
}

Android 源码中的应用

Android 框架中广泛使用了策略模式，最典型的例子是属性动画中的插值器。

时间插值器

TimeInterpolator 接口定义了插值算法，不同的实现类决定了动画的速度变化效果。

public interface TimeInterpolator {
    float getInterpolation(float input);
}

常见的实现包括 AccelerateDecelerateInterpolator（先加速后减速）、LinearInterpolator（线性）等。

估值器

TypeEvaluator 接口用于计算属性值的变化。

public interface TypeEvaluator<T> {
    T evaluate(float fraction, T startValue, T endValue);
}

例如 ArgbEvaluator 用于颜色值的插值计算，它分别对 Alpha、Red、Green、Blue 四个通道进行线性插值。

策略模式优缺点分析

优点

1. 符合开闭原则：增加新策略只需新增具体策略类，无需修改现有代码。
2. 避免多重条件判断：消除了大量的 if-else 或 switch-case 语句。
3. 复用性好：算法和上下文解耦，便于维护和测试。
4. 灵活扩展：可以在运行时动态切换策略。

缺点

1. 策略数量膨胀：每种算法都需要一个具体策略类，可能导致类数量增加。
2. 客户端知晓所有策略：客户端需要了解不同策略之间的区别才能选择合适的策略。
3. 性能开销：频繁的函数调用和对象创建可能带来轻微的性能损耗（通常可忽略）。

策略模式与状态模式的区别

两者结构相似，但意图不同：

• 策略模式：关注的是算法的替换，目的是消除条件分支，算法之间没有明显的状态依赖关系。
• 状态模式：关注的是状态的转换，对象内部状态改变导致其行为改变，状态之间有明确的转换规则。

总结

策略模式是一种强大的设计模式，能够有效降低代码耦合度，提高系统的可扩展性。通过本文的学习，我们掌握了策略模式的基本结构、优化技巧以及在 Android 开发中的实际应用。在实际开发中，建议结合工厂模式和反射机制，构建更加灵活和健壮的架构。