Java策略模式的简单应用实现方法

接下来我会详细讲解“Java策略模式的简单应用实现方法”的完整攻略。

什么是策略模式？

策略模式是一种行为型设计模式，它允许你定义一组算法，将每个算法都封装起来，并使它们之间可以互换。该模式让算法的变化独立于使用它们的客户端，即可以在不修改客户端代码的情况下更换执行算法。

策略模式的应用场景

• 当需要在不同情况下使用不同的算法时，可以使用策略模式，将每种算法都封装起来，方便在不同情况下使用。
• 当有一些相关的类，它们的区别仅在于它们的行为，可以使用策略模式，将行为抽象出来，做成接口，由具体类去实现。

策略模式的简单应用实现方法

步骤一：定义策略接口

首先，需要定义一个策略接口，该接口声明了需要执行算法的方法。

public interface Strategy {
    void execute();
}

步骤二：定义策略类

为每种算法都创建一个策略类，实现上述策略接口，并实现 execute() 方法。

例如，为文字消息、语音消息和视频消息分别定义三个策略类：

public class TextStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("发送了一条文字消息。");
    }
}

public class VoiceStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("发送了一条语音消息。");
    }
}

public class VideoStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("发送了一条视频消息。");
    }
}

步骤三：定义策略上下文

定义一个策略上下文类，负责管理不同的策略。

public class StrategyContext {
    // 定义策略
    private Strategy strategy;

    public StrategyContext(Strategy strategy) {
        this.strategy = strategy;
    }

    // 执行策略
    public void executeStrategy() {
        strategy.execute();
    }
}

步骤四：客户端使用策略模式

客户端根据不同的情况来选择使用不同的策略。

public class Client {
    public static void main(String[] args) {
        // 使用文本策略
        StrategyContext context = new StrategyContext(new TextStrategy());
        context.executeStrategy();

        // 使用语音策略
        context = new StrategyContext(new VoiceStrategy());
        context.executeStrategy();

        // 使用视频策略
        context = new StrategyContext(new VideoStrategy());
        context.executeStrategy();
    }
}

这个例子中，我们使用了策略模式为发送消息提供了一种灵活的方式，根据不同的需求可以选择不同的策略。

示例说明

示例一

假设有一个电商网站，根据不同的用户等级提供不同的折扣。可以使用策略模式为不同的用户等级提供不同的策略，例如：

public interface DiscountStrategy {
    double calculateDiscount(double originalPrice);
}

public class VipDiscountStrategy implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * 0.8;
    }
}

public class SuperVipDiscountStrategy implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * 0.7;
    }
}

public class PlatinumVipDiscountStrategy implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        return originalPrice * 0.6;
    }
}

public class StrategyContext {
    private DiscountStrategy strategy;

    public StrategyContext(DiscountStrategy strategy) {
        this.strategy = strategy;
    }

    public double calculateDiscount(double originalPrice) {
        return strategy.calculateDiscount(originalPrice);
    }
}

public class Client {
    public static void main(String[] args) {
        // 根据不同的用户等级提供不同的折扣
        // VIP用户
        DiscountStrategy strategy = new VipDiscountStrategy();
        StrategyContext context = new StrategyContext(strategy);
        System.out.println(context.calculateDiscount(100.0));

        // 超级VIP用户
        strategy = new SuperVipDiscountStrategy();
        context = new StrategyContext(strategy);
        System.out.println(context.calculateDiscount(100.0));

        // 铂金VIP用户
        strategy = new PlatinumVipDiscountStrategy();
        context = new StrategyContext(strategy);
        System.out.println(context.calculateDiscount(100.0));
    }
}

示例二

假设有一个游戏，有多个游戏角色可以选择。每个游戏角色都有不同的攻击技能和防御技能，可以使用策略模式为每个游戏角色提供不同的技能，例如：

public interface AttackStrategy {
    void attack();
}

public class SwordAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("使用剑进行攻击。");
    }
}

public class MagicAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("使用魔法进行攻击。");
    }
}

public interface DefenseStrategy {
    void defense();
}

public class ShieldDefenseStrategy implements DefenseStrategy {
    @Override
    public void defense() {
        System.out.println("使用盾牌进行防御。");
    }
}

public class DodgeDefenseStrategy implements DefenseStrategy {
    @Override
    public void defense() {
        System.out.println("使用闪避进行防御。");
    }
}

public class Character {
    private AttackStrategy attackStrategy;
    private DefenseStrategy defenseStrategy;

    public Character(AttackStrategy attackStrategy, DefenseStrategy defenseStrategy) {
        this.attackStrategy = attackStrategy;
        this.defenseStrategy = defenseStrategy;
    }

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

    public void defense() {
        defenseStrategy.defense();
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建一个游戏角色
        Character character = new Character(new SwordAttackStrategy(), new ShieldDefenseStrategy());
        character.attack();
        character.defense();

        // 创建另外一个游戏角色
        character = new Character(new MagicAttackStrategy(), new DodgeDefenseStrategy());
        character.attack();
        character.defense();
    }
}

在这个例子中，我们给游戏角色提供了不同的攻击技能和防御技能，可以根据角色的不同需求选择不同的策略。