策略模式简介

概念：

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装到独立的类中，使得它们可以互相替换。通过使用策略模式，客户端可以在运行时选择不同的算法来解决问题。

特点：

1. 将算法和使用该算法的客户端代码分离，使得它们可以独立变化。
2. 可以动态切换和选择不同的算法。
3. 提高代码复用性和可维护性。

优点：

1. 灵活性：能够在运行时动态切换和选择不同的算法或行为。
2. 易于扩展：新增加一个具体策略类即可，并且遵循开闭原则。
3. 降低耦合度：将各个具体策略与上下文解耦，减少彼此之间依赖关系。

缺点：

1. 增加了系统中类的数量和复杂度。
2. 客户端必须理解各个具体策略之间的区别以及如何选择合适的策略。

适用场景：

1. 当有多个相关但不同实现方式的算法时，可以使用策略模式将这些算法封装成独立的类。
2. 当需要在运行时动态地选择算法或行为时，可以使用策略模式来实现灵活性。

实现方式：

使用接口方式

实现原理：

通过定义一个公共接口，所有具体策略类都要实现这个接口，并在上下文类中持有该接口类型的对象。在运行时，根据需要选择合适的具体策略对象，并调用其方法来执行相应的算法。

实现代码：

// 定义一个公共策略接口
interface Strategy {
    void execute();
}

// 具体策略类A
class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
        // 具体算法A的实现逻辑...
    }
}

// 具体策略类B
class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
        // 具体算法B的实现逻辑...
    }
}

// 上下文类Context持有一个Strategy对象，在运行时可以切换不同具体策略
class Context {
    private Strategy strategy;

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

    public void executeStrategy() {
        if (strategy != null) {
            strategy.execute();
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        // 创建具体策略对象
        Strategy strategyA = new ConcreteStrategyA();
        Strategy strategyB = new ConcreteStrategyB();

        // 创建上下文对象，并设置具体策略对象
        Context context = new Context();
        
      	context.setStrategy(strategyA);
      	context.executeStrategy();  // 执行策略A
        
      	context.setStrategy(strategyB);
      	context.executeStrategy();  // 执行策略B
    }
}

在上述示例中，通过定义Context类持有一个Stategy接口类型的成员变量，可以动态切换和选择不同的算法。每个具体的策略类都实现了execute()方法来执行自己特定的算法逻辑。在客户端代码中，可以根据需要创建不同的具体策略对象，并将其传递给上下文类进行执行。

存在的问题：

1. 策略模式使用接口方式实现时，可能会导致代码膨胀，因为每个具体策略类都需要实现整个接口，即使某些方法对于特定的具体策略并不适用。
2. 当需要新增一种算法时，必须创建新的具体策略类并实现整个接口。

使用抽象类方式

实现原理：

通过定义一个抽象基类作为所有具体策略类的父类，并在其中声明抽象方法。每个具体子类提供自己特定实现。上下文通过持有抽象基类对象来调用不同具体子类。

实现代码：

// 定义一个公共抽象基类
abstract class Strategy {
    public abstract void execute();
}

// 具体策略子类A
class ConcreteStrategyA extends Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
        // 具体算法A的实现逻辑...
    }
}

// 具体策略子B
class ConcreteStrategyB extends Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
        // 具体算法B的实现逻辑...
    }
}

// 上下文Context持有一个Strategy对象，在运行时可以切换不同具体策略
class Context {
    private Strategy strategy;

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

    public void executeStrategy() {
        if (strategy != null) {
            strategy.execute();
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        // 创建具体策略对象
        Strategy strategyA = new ConcreteStrategyA();
        Strategy strategyB = new ConcreteStrategyB();

        // 创建上下文对象，并设置具体策略对象
        Context context = new Context();
        
      	context.setStrategy(strategyA);
      	context.executeStrategy();  // 执行策略A
        
      	context.setStrategy(strategyB);
      	context.executeStrategy();  // 执行策略B
    }
}