《Java 策略模式的 “高阶魔法秀”》

嘿，各位 Java 编程江湖里的 "大侠" 们！咱之前唠过策略模式这根 "万能魔杖"，能把乱糟糟的代码 "妖魔鬼怪" 收拾得服服帖帖。今儿个，可得再深挖挖它的 "高阶魔法"，那可真是一招比一招酷炫，像烟花秀似的，层层绽放在代码天地里，保准让你惊掉下巴，大喊 "妙啊"！

一、策略工厂与反射："魔法宝盒" 的智能管家

想象你有个超级大的 "魔法宝盒"（对应策略模式体系），里面塞了五花八门的 "魔法秘籍"（策略类），啥 "火焰冲击咒秘籍""冰霜禁锢典""治愈柔光法纲要"，以前呢，你每次想用本秘籍，得在宝盒里乱翻一气，手动挑出来施展魔法（手动创建策略类实例），麻烦得很呐！这时候，策略工厂搭配反射机制，就像给宝盒请了个 "智能管家"。

这管家手里攥着本 "魔法索引簿"（策略工厂维护的映射关系，像个 Map），簿子上清晰写着："'火焰冲击'对应 3 号格子秘籍（类），'冰霜禁锢'对应 7 号格子......"。你只要冲管家喊一嗓子，"嘿，给我拿'冰霜禁锢'秘籍来！" 管家麻溜地根据索引，启动 "魔法反射镜"（利用反射机制），一道神秘光射进宝盒，精准揪出 7 号格子的秘籍，瞬间递到你手上，让你能顺畅施展魔法。

代码瞅瞅就像这样：

dart 复制代码

import java.util.HashMap;
import java.util.Map;

// 策略工厂类，咱这机灵的"魔法管家"
class MagicStrategyFactory {
    private static Map<String, Class<? extends MagicStrategy>> strategyMap = new HashMap<>();

    static {
        strategyMap.put("火焰冲击", FireballStrategy.class);
        strategyMap.put("冰霜禁锢", IceLockStrategy.class);
        strategyMap.put("治愈柔光", HealingLightStrategy.class);
    }

    public static MagicStrategy getStrategy(String strategyName) {
        try {
            Class<? extends MagicStrategy> strategyClass = strategyMap.get(strategyName);
            if (strategyClass!= null) {
                return strategyClass.getConstructor().newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

在 "江湖"（客户端代码）闯荡时，你这么使：

typescript 复制代码

public class Main {
    public static void main(String[] args) {
        MagicStrategy strategy = MagicStrategyFactory.getStrategy("冰霜禁锢");
        if (strategy!= null) {
            strategy.castSpell();
        }
    }
}

好家伙，这一下，策略的调用跟坐了火箭似的，又快又准，还特灵活，你想换策略，改改配置（索引簿内容）或者喊句新指令就行，宝盒里再多秘籍也不怕乱套咯！

二、策略组合与嵌套："魔法鸡尾酒" 与 "套娃魔法阵"

策略组合：调制 "魔法鸡尾酒"

有时候，单使一招魔法（单个策略）不过瘾，得来个 "魔法鸡尾酒"，把几种魔法效果一股脑混一块儿。就好比电商价格大战里，商品价格得先过 "折扣搅拌机"（折扣策略）搅一搅，再进 "税收蒸馏器"（税收策略）升华升华，才是最终价。

咱瞅瞅代码咋捣鼓的，先定义几个 "魔法调酒原料"（策略接口及实现类）：

java 复制代码

// 折扣策略接口，像个"折扣搅拌机"开关
interface DiscountStrategy {
    double applyDiscount(double price);
}

// 税收策略接口，咱这"税收蒸馏器"操控台
interface TaxStrategy {
    double applyTax(double price);
}

// 组合策略类，正儿八经的"魔法调酒大师"
class ComboStrategy implements DiscountStrategy, TaxStrategy {
    private DiscountStrategy discountStrategy;
    private TaxStrategy taxStrategy;

    public ComboStrategy(DiscountStrategy discountStrategy, TaxStrategy taxStrategy) {
        this.discountStrategy = discountStrategy;
        this.taxStrategy = taxStrategy;
    }

    @Override
    public double applyDiscount(double price) {
        return discountStrategy.applyDiscount(price);
    }

    @Override
    public double applyTax(double price) {
        return taxStrategy.applyTax(discountStrategy.applyDiscount(price));
    }
}

在 "电商战场"（客户端）这么用：

ini 复制代码

public class Main {
    public static void main(String[] args) {
        DiscountStrategy discountStrategy = new TenPercentDiscountStrategy();
        TaxStrategy taxStrategy = new FivePercentTaxStrategy();
        ComboStrategy comboStrategy = new ComboStrategy(discountStrategy, taxStrategy);
        double originalPrice = 100.0;
        double finalPrice = comboStrategy.applyTax(comboStrategy.applyDiscount(originalPrice));
        System.out.println("最终价格: " + finalPrice);
    }
}

这一番操作，价格在策略组合里 "七拐八绕"，最后出来个完美 "成品"，跟精心调好的鸡尾酒似的，美味（合理）又上头（高效）！

策略嵌套："套娃魔法阵" 显威
再讲讲这策略嵌套，那简直是俄罗斯套娃成精，魔法里套魔法。就像游戏角色权限管理这事儿，得先过 "角色外衣"（基于角色的权限策略）筛查，再捅破 "等级内衣"（用户级别权限策略）细究，双重把关才让进 "魔法城堡"（访问资源）。

typescript 复制代码

// 权限检查策略接口，城堡"门禁规则手册"
interface PermissionCheckStrategy {
    boolean checkPermission(User user, Resource resource);
}

// 用户级别权限策略类，这"等级内衣"有讲究
class UserLevelPermissionStrategy implements PermissionCheckStrategy {
    @Override
    public boolean checkPermission(User user, Resource resource) {
        // 根据用户级别检查权限逻辑，像摸"内衣"标签对不对
        return user.getUserLevel().canAccess(resource);
    }
}

// 基于角色的权限策略类，"角色外衣"得亮眼
class RoleBasedPermissionStrategy implements PermissionCheckStrategy {
    @Override
    public boolean checkPermission(User user, Resource resource) {
        // 根据用户角色检查权限逻辑，瞅"外衣"款式合不合规
        return user.getRoles().stream().anyMatch(role -> role.canAccess(resource));
    }
}

// 组合权限策略类，"套娃达人"上线
class CompositePermissionStrategy implements PermissionCheckStrategy {
    private PermissionCheckStrategy innerStrategy;
    private PermissionCheckStrategy outerStrategy;

    public CompositePermissionStrategy(PermissionCheckStrategy innerStrategy, PermissionCheckStrategy outerStrategy) {
        this.innerStrategy = innerStrategy;
        this.outerStrategy = outerStrategy;
    }

    @Override
    public boolean checkPermission(User user, Resource resource) {
        return outerStrategy.checkPermission(user, resource) && innerStrategy.checkPermission(user, resource);
    }
}

客户端代码里 "把玩套娃"：

ini 复制代码

public class Main {
    public static void main(String[] args) {
        PermissionCheckStrategy innerStrategy = new UserLevelPermissionStrategy();
        PermissionCheckStrategy outerStrategy = new RoleBasedPermissionStrategy();
        CompositePermissionStrategy compositeStrategy = new CompositePermissionStrategy(innerStrategy, outerStrategy);
        User user = new User();
        Resource resource = new Resource();
        boolean hasPermission = compositeStrategy.checkPermission(user, resource);
        System.out.println("用户是否有权限: " + hasPermission);
    }
}

这层层嵌套，跟剥洋葱、拆套娃似的，把关贼严，让权限管理稳稳当当，一丝不乱，魔法城堡 "固若金汤" 呐！

三、策略与状态结合："变形金刚" 魔法随形

策略依状态切换："变形金刚" 的魔法变身
想象游戏里的角色，像个 "变形金刚"，生命值满格时（状态好），攻击是 "重拳出击"（正常攻击策略），虎虎生风；一旦血量告急（状态变了），就变成 "轻拳撩拨"（虚弱攻击策略），保存实力。

java 复制代码

// 攻击策略接口，"攻击招式秘籍"大纲
interface AttackStrategy {
    void attack(Enemy enemy);
}

// 正常攻击策略类，"重拳秘籍"
class NormalAttackStrategy implements AttackStrategy {
    @Override
    public void attack(Enemy enemy) {
        // 正常攻击逻辑，拳头呼呼生风，伤害拉满
        System.out.println("角色发动正常攻击，对敌人造成大量伤害。");
    }
}

// 虚弱攻击策略类，"轻拳宝典"
class WeakAttackStrategy implements AttackStrategy {
    @Override
    public void attack(Enemy enemy) {
        // 虚弱攻击逻辑，软绵绵一拳，意思意思
        System.out.println("角色发动虚弱攻击，对敌人造成少量伤害。");
    }
}

// 游戏角色类，这"变形金刚"主角
class GameCharacter {
    private AttackStrategy attackStrategy;
    private double health;

    public GameCharacter(double health) {
        this.health = health;
        if (health > 50) {
            this.attackStrategy = new NormalAttackStrategy();
        } else {
            this.attackStrategy = new WeakAttackStrategy();
        }
    }

    public void setHealth(double health) {
        this.health = health;
        if (health > 50) {
            this.attackStrategy = new NormalAttackStrategy();
        } else {
            this.attackStrategy = new WeakAttackStrategy();
        }
    }

    public void attack(Enemy enemy) {
        attackStrategy.attack(enemy);
    }
}

在 "游戏战场" 这么玩：

ini 复制代码

public class Main {
    public static void main(String[] args) {
        GameCharacter character = new GameCharacter(70);
        Enemy enemy = new Enemy();
        character.attack(enemy);

        character.setHealth(30);
        character.attack(enemy);
    }
}

嘿，这角色机灵得很，随着血量 "脸色"（状态）一变，攻击策略立马 "换装"，时刻保持战斗 "最优解"，在战场上灵活得像条泥鳅！

状态驱动策略链："魔法传送带" 的流程盛宴
再瞧瞧订单处理这事儿，像个 "魔法传送带"，订单状态一滚动（变化），就触发一连串 "魔法工序"（策略链）。先过 "支付安检门"（支付验证策略），再上 "库存扫描台"（库存检查策略），最后跳上 "发货火箭"（发货策略），"嗖" 地奔向客户。

typescript 复制代码

// 订单处理策略接口，"魔法工序手册"
interface OrderProcessingStrategy {
    void process(Order order);
    OrderProcessingStrategy getNextStrategy();
}

// 支付验证策略类，"支付安检门"开关
class PaymentVerificationStrategy implements OrderProcessingStrategy {
    private OrderProcessingStrategy nextStrategy;

    @Override
    public void process(Order order) {
        // 支付验证逻辑，火眼金睛查破绽
        System.out.println("验证订单支付信息。");
    }

    @Override
    public OrderProcessingStrategy getNextStrategy() {
        return nextStrategy;
    }

    public void setNextStrategy(OrderProcessingStrategy nextStrategy) {
        this.nextStrategy = nextStrategy;
    }
}

// 库存检查策略类，"库存扫描台"操控器
class InventoryCheckStrategy implements OrderProcessingStrategy {
    private OrderProcessingStrategy nextStrategy;

    @Override
    public void process(Order order) {
        // 库存检查逻辑，雷达眼扫库存
        System.out.println("检查库存是否充足。");
    }

    @Override
    public OrderProcessingStrategy getNextStrategy() {
        return nextStrategy;
    }

    public void setNextStrategy(OrderProcessingStrategy nextStrategy) {
        this.nextStrategy = nextStrategy;
    }
}

// 发货策略类，"发货火箭"发射键
class ShippingStrategy implements OrderProcessingStrategy {
    @Override
    public void process(Order order) {
        // 发货逻辑，火箭点火，一飞冲天
        System.out.println("安排发货。");
    }

    @Override
    public OrderProcessingStrategy getNextStrategy() {
        return null;
    }
}

在 "订单工厂"（Order 类）里组装 "传送带"：

ini 复制代码

class Order {
    private OrderProcessingStrategy currentStrategy;

    public Order() {
        PaymentVerificationStrategy paymentStrategy = new PaymentVerificationStrategy();
        InventoryCheckStrategy inventoryStrategy = new InventoryCheckStrategy();
        ShippingStrategy shippingStrategy = new ShippingStrategy();

        paymentStrategy.setNextStrategy(inventoryStrategy);
        inventoryStrategy.setNextStrategy(shippingStrategy);

        this.currentStrategy = paymentStrategy;
    }

    public void processOrder() {
        currentStrategy.process(this);
        OrderProcessingStrategy nextStrategy = currentStrategy.getNextStrategy();
        if (nextStrategy!= null) {
            currentStrategy = nextStrategy;
            processOrder();
        }
    }
}

客户端代码里启动 "传送带"：

vbnet 复制代码

public class Main {
    public static void main(String[] args) {
        Order order = new Order();
        order.processOrder();
    }
}

这策略链跟着订单状态 "亦步亦趋"，一环扣一环，流程顺畅得像德芙巧克力，纵享丝滑，订单处理高效又有序，妥妥的 "业界良心" 呐！

所以呐，大侠们，把策略模式这些高阶魔法吃透，代码江湖任你闯荡，不管碰上啥疑难杂症，都能像老中医把脉开药，药到病除，轻松拿捏，编程之路那叫一个 "一马平川"，奥利给！