策略模式¶

package com.example.behavioral.strategy;

/**
 * 策略模式 - 反例
 * 问题：calculatePrice 方法包含所有折扣逻辑，新增折扣类型必须修改原方法
 */
public class StrategyBadExample {
    public static void main(String[] args) {
        StrategyBadExample demo = new StrategyBadExample();
        System.out.println(demo.calculatePrice(100.0, "vip"));
        System.out.println(demo.calculatePrice(100.0, "new_user"));
        System.out.println(demo.calculatePrice(100.0, "normal"));
        // 新增"满减"折扣？要改这个方法的 if-else ❌
    }

    // ❌ 所有折扣逻辑堆在一个方法里
    public double calculatePrice(double price, String userType) {
        if ("vip".equals(userType)) {
            return price * 0.8; // VIP 八折
        } else if ("new_user".equals(userType)) {
            return price - 10;  // 新用户减10元
        } else {
            return price;       // 无折扣
        }
        // 新增满减？这里再加 else if ❌
    }
}

package com.example.behavioral.strategy;

/**
 * 策略模式 - 正例
 * 每种折扣策略独立封装，新增策略不修改已有代码（开闭原则）
 */
public class StrategyExample {
    public static void main(String[] args) {
        OrderService service = new OrderService();

        // ✅ 运行时切换策略
        service.setDiscountStrategy(new VipDiscount());
        System.out.println("VIP价格: " + service.calculatePrice(100.0));      // 80.0

        service.setDiscountStrategy(new NewUserDiscount());
        System.out.println("新用户价格: " + service.calculatePrice(100.0));   // 90.0

        service.setDiscountStrategy(new NoDiscount());
        System.out.println("原价: " + service.calculatePrice(100.0));         // 100.0

        // ✅ 新增满减策略：只需新建 FullReductionDiscount，不改任何已有代码
    }
}

// 策略接口
interface DiscountStrategy {
    double apply(double originalPrice);
}

// 具体策略：VIP 八折
class VipDiscount implements DiscountStrategy {
    @Override public double apply(double price) { return price * 0.8; }
}

// 具体策略：新用户减 10 元
class NewUserDiscount implements DiscountStrategy {
    @Override public double apply(double price) { return Math.max(0, price - 10); }
}

// 具体策略：无折扣
class NoDiscount implements DiscountStrategy {
    @Override public double apply(double price) { return price; }
}

// 上下文：持有策略引用，可运行时替换
class OrderService {
    private DiscountStrategy discountStrategy = new NoDiscount(); // 默认无折扣

    public void setDiscountStrategy(DiscountStrategy strategy) {
        this.discountStrategy = strategy;
    }

    public double calculatePrice(double originalPrice) {
        return discountStrategy.apply(originalPrice); // 委托给策略
    }
}

public class DiscountStrategyFactory {
    // 策略对象无状态，预创建后缓存复用
    private static final Map<OrderType, DiscountStrategy> strategies = new HashMap<>();

    static {
        strategies.put(OrderType.NORMAL,    new NormalDiscountStrategy());
        strategies.put(OrderType.GROUPON,   new GrouponDiscountStrategy());
        strategies.put(OrderType.PROMOTION, new PromotionDiscountStrategy());
    }

    public static DiscountStrategy getDiscountStrategy(OrderType type) {
        return strategies.get(type);  // 查表，O(1)，无 if-else
    }
}

// 使用方：完全没有分支判断
public class OrderService {
    public double discount(Order order) {
        DiscountStrategy strategy =
            DiscountStrategyFactory.getDiscountStrategy(order.getType());
        return strategy.calDiscount(order);
    }
}

public class Sorter {
    private static final long GB = 1000 * 1000 * 1000;

    // 将「范围 → 算法」的映射表化，新增策略只改这里
    private static final List<AlgRange> algs = new ArrayList<>();
    static {
        algs.add(new AlgRange(0,       6 * GB,           new QuickSort()));
        algs.add(new AlgRange(6 * GB,  10 * GB,          new ExternalSort()));
        algs.add(new AlgRange(10 * GB, 100 * GB,         new ConcurrentExternalSort()));
        algs.add(new AlgRange(100 * GB, Long.MAX_VALUE,  new MapReduceSort()));
    }

    public void sortFile(String filePath) {
        long fileSize = new File(filePath).length();
        algs.stream()
            .filter(r -> r.inRange(fileSize))
            .findFirst()
            .map(AlgRange::getAlg)
            .ifPresent(alg -> alg.sort(filePath));
    }
}