设计模式(018)行为型之策略模式

策略模式是一种行为设计模式，它定义了一系列算法，将每个算法封装成一个对象，并使它们可以互换。策略模式使得算法的变化可以独立于使用算法的客户端。在策略模式中，有三个核心角色：策略接口（Strategy）、具体策略（ConcreteStrategy）、以及上下文（Context）。
① 策略接口（Strategy） ：定义了一个算法族的接口。
② 具体策略（ConcreteStrategy） ：实现了策略接口，封装了具体的算法实现。
③ 上下文（Context） ：维护一个对策略对象的引用，负责将客户端请求委托给具体的策略对象。
策略模式的核心思想是将算法的定义与使用分离，使得算法可以独立于客户端进行变化、扩展和替换。

1、场景设计

实现场景：设计A、B两种策略，同一个客户端可以根据需要从两种策略中选择使用。

2、C++实现

`Strategy` 是策略接口，定义了一个纯虚的 `execute()` 方法。`ConcreteStrategyA` 和 `ConcreteStrategyB` 是具体策略，分别实现了 `execute()` 方法来执行具体的算法。`Context` 是上下文，持有一个策略对象的指针，并且负责将客户端的请求委托给具体的策略对象。在 `main()` 函数中，我们创建了两个具体策略对象，然后通过 `Context` 对象执行了这些策略。

cpp 复制代码

#include <iostream>

// 策略接口
class Strategy {
    public:
        virtual void execute() = 0;
};

// 具体策略A
class ConcreteStrategyA : public Strategy {
    public:
        void execute() override {
            std::cout << "Executing strategy A" << std::endl;
        }
};

// 具体策略B
class ConcreteStrategyB : public Strategy {
    public:
        void execute() override {
            std::cout << "Executing strategy B" << std::endl;
        }
};

// 上下文
class Context {
    private:
        Strategy *strategy;

    public:
        Context(Strategy *strat) : strategy(strat) {}

        void setStrategy(Strategy *strat) {
            strategy = strat;
        }

        void executeStrategy() {
            if (strategy) {
                strategy->execute();
            }
        }
};

int main() {
    ConcreteStrategyA strategyA;
    ConcreteStrategyB strategyB;

    Context context(&strategyA);
    context.executeStrategy();

    context.setStrategy(&strategyB);
    context.executeStrategy();

    return 0;
}

3、Java实现

`Strategy` 是策略接口，定义了一个执行算法的方法 `execute()`。`ConcreteStrategyA` 和 `ConcreteStrategyB` 是具体策略，分别实现了 `execute()` 方法来执行具体的算法。`Context` 是上下文，维护一个对策略对象的引用，并且负责将客户端的请求委托给具体的策略对象。在 `main()` 方法中，我们创建了上下文对象，并分别设置了两种不同的策略，然后执行策略。

java 复制代码

package behavioralpattern.strategy;

public class StrategyDemo {
    // 策略接口
    interface Strategy {
        void execute();
    }
    // 具体策略A
    static class ConcreteStrategyA implements Strategy {
        @Override
        public void execute() {
            System.out.println("Executing strategy A");
        }
    }
    // 具体策略B
    static class ConcreteStrategyB implements Strategy {
        @Override
        public void execute() {
            System.out.println("Executing strategy B");
        }
    }
    // 上下文
    static class Context {
        private Strategy strategy;

        public void setStrategy(Strategy strategy) {
            this.strategy = strategy;
        }

        public void executeStrategy() {
            strategy.execute();
        }
    }
    public static void main(String[] args) {
        Context context = new Context();

        Strategy strategyA = new ConcreteStrategyA();
        Strategy strategyB = new ConcreteStrategyB();

        context.setStrategy(strategyA);
        context.executeStrategy();

        context.setStrategy(strategyB);
        context.executeStrategy();
    }
}