使用策略模式替代 if-else 的 Java 实现

最新推荐文章于 2024-07-13 02:30:36 发布

DevNinja

最新推荐文章于 2024-07-13 02:30:36 发布

阅读量594

点赞数 2

本文链接：https://blog.csdn.net/DevNinja/article/details/133213287

版权

策略模式是一种面向对象设计模式，它允许在运行时选择算法的行为。相比于使用大量的 if-else 语句来实现不同的条件分支，策略模式提供了一种更加灵活和可扩展的方式来管理不同的行为，同时降低了代码的复杂性。

在本文中，我们将使用 Java 编程语言来展示如何使用策略模式来替代 if-else 语句。

问题背景

假设我们正在开发一个游戏，其中有多个角色，每个角色都有不同的攻击方式。根据角色的类型，我们需要执行不同的攻击逻辑。传统的解决方案是使用 if-else 语句来判断角色的类型，并执行相应的攻击逻辑。下面是一个简单的示例代码：

public class GameCharacter {
    private String type;
    
    public GameCharacter(String type) {
        this.type = type;
    }
    
    public void attack() {
        if (type.equals("warrior")) {
            System.out.println("Warrior attacks with a sword.");
        } else if (type.equals("mage")) {
            System.out.println("Mage attacks with a spell.");
        } else if (type.equals("archer")) {
            System.out.println("Archer attacks with a bow.");
        } else {
            System.out.println("Unknown character type.");
        }
    }
}

上述代码中，GameCharacter 类根据传入的角色类型执行不同的攻击逻辑。但是，如果我们需要添加更多的角色类型或者修改现有的角色类型时，就需要修改 attack 方法中的 if-else 语句，这样会导致代码的可维护性变差。

使用策略模式

为了使用策略模式来替代 if-else 语句，我们首先需要定义一个策略接口（AttackStrategy），该接口包含一个 attack 方法，用于执行攻击逻辑。然后，我们可以为每个角色类型实现一个具体的攻击策略类，这些策略类都实现了 AttackStrategy 接口。最后，在 GameCharacter 类中引入一个成员变量来存储具体的攻击策略，并在 attack 方法中调用该策略的 attack 方法。

下面是使用策略模式重构后的代码：

public interface AttackStrategy {
    void attack();
}

public class SwordAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("Warrior attacks with a sword.");
    }
}

public class SpellAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("Mage attacks with a spell.");
    }
}

public class BowAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("Archer attacks with a bow.");
    }
}

public class GameCharacter {
    private AttackStrategy attackStrategy;
    
    public GameCharacter(AttackStrategy attackStrategy) {
        this.attackStrategy = attackStrategy;
    }
    
    public void attack() {
        attackStrategy.attack();
    }
}

在上述代码中，我们首先定义了一个 AttackStrategy 接口，包含了 attack 方法。然后，我们为每个角色类型实现了具体的攻击策略类：SwordAttackStrategy、SpellAttackStrategy 和 BowAttackStrategy。这些策略类分别实现了 AttackStrategy 接口，并实现了各自的攻击逻辑。

接下来，在 GameCharacter 类中引入了一个成员变量 attackStrategy，用于存储具体的攻击策略。在构造方法中传入相应的策略对象，并在 attack 方法中调用 attackStrategy 的 attack 方法。

现在，我们可以通过创建不同的攻击策略对象来实例现不同类型的角色，并调用它们的 attack 方法。下面是示例代码：

public class Main {
    public static void main(String[] args) {
        AttackStrategy warriorStrategy = new SwordAttackStrategy();
        GameCharacter warrior = new GameCharacter(warriorStrategy);
        warrior.attack(); // 输出：Warrior attacks with a sword.
        
        AttackStrategy mageStrategy = new SpellAttackStrategy();
        GameCharacter mage = new GameCharacter(mageStrategy);
        mage.attack(); // 输出：Mage attacks with a spell.
        
        AttackStrategy archerStrategy = new BowAttackStrategy();
        GameCharacter archer = new GameCharacter(archerStrategy);
        archer.attack(); // 输出：Archer attacks with a bow.
    }
}

在上述代码中，我们创建了一个 SwordAttackStrategy 对象作为战士的攻击策略，并将其传递给 GameCharacter 类的构造方法。同样地，我们创建了 SpellAttackStrategy 和 BowAttackStrategy 对象作为法师和弓箭手的攻击策略，并将它们分别传递给相应的 GameCharacter 对象。最后，我们调用每个角色对象的 attack 方法，分别输出了不同的攻击方式。

通过使用策略模式，我们成功地将原本使用 if-else 语句实现的条件分支逻辑转化为了一组可复用的策略类。这种方式使得代码更加灵活、可扩展，并且提高了代码的可维护性。

总结：