定义：定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

原理：通过定义策略接口和具体策略类，将算法封装为对象，并在运行时选择使用。

优点：

• 灵活性：可以动态选择算法。
• 易于扩展：可以新增策略而不影响现有代码。
• 四个组件构成 策略接口 策略实现 策略上下文 策略调用

我现在想定义鸭子，鸭子有会飞的，不会飞的，我们将飞定义成一个strategy

策略接口（飞行）

interface Strategy_Fly {
    void fly();
}

策略接口（Strategy Interface）：

• 定义了一个策略接口 Strategy_Fly，接口中定义了飞行的行为 fly()。
• 这是策略模式的核心，所有飞行行为都要实现这个接口，不同的实现可以根据具体需求来定义飞行方式。

 

策略实现1（不会飞）

public class StrategyFlyNoWay implements Strategy_Fly {
    @Override
    public void fly() {
        System.out.println("No Fly");
    }
}

策略实现（Strategy Implementations）：

• StrategyFlyNoWay 和 StrategyFlyFast 分别实现了 Strategy_Fly 接口，定义了不同的飞行行为。
  • StrategyFlyNoWay 表示不会飞，打印 "No Fly".
  • StrategyFlyFast 表示会飞，打印 "Fly".
• 这种设计使得飞行行为是可扩展的，未来可以添加更多飞行行为，而不需要修改现有的代码。

 策略实现2（会飞）

public class StrategyFlyFast implements Strategy_Fly {
    @Override
    public void fly(){
        System.out.println("fly");
    }
}

策略实现（Strategy Implementations）：

• StrategyFlyNoWay 和 StrategyFlyFast 分别实现了 Strategy_Fly 接口，定义了不同的飞行行为。
  • StrategyFlyNoWay 表示不会飞，打印 "No Fly".
  • StrategyFlyFast 表示会飞，打印 "Fly".
• 这种设计使得飞行行为是可扩展的，未来可以添加更多飞行行为，而不需要修改现有的代码。

策略上下文（鸭子类）

public abstract class  Duck {
    public Strategy_Fly strategyFly;

    public void performFly(){
        strategyFly.fly();
    }

    public void setFlyBehavior(Strategy_Fly fb) {
        strategyFly = fb;}

    public abstract void display();

}

策略上下文（Context - Duck 类）：

• Duck 是一个抽象类，它有一个 Strategy_Fly 类型的成员变量 strategyFly，用于表示当前鸭子的飞行行为。
• performFly() 方法调用了 strategyFly 的 fly() 方法，表示让鸭子执行它当前的飞行行为。
• setFlyBehavior() 方法允许在运行时动态改变鸭子的飞行行为。

 

策略调用（橡皮鸭子类，main函数）

public class RubberDuck extends Duck{
    @Override
    public void display() {
        System.out.println("Rubber Duck");
    }

    public RubberDuck(){
        strategyFly = new StrategyFlyNoWay() ;


    }
}


public class Main {
    public static void main(String[] args) {

        Duck duck1 = new RubberDuck();

        duck1.setFlyBehavior(new StrategyFlyFast());

    }
}

策略调用（RubberDuck 类和 Main 函数）：

• 在 RubberDuck 类的构造函数中，默认将 strategyFly 设置为 StrategyFlyNoWay，表示橡皮鸭不会飞。
• 在 main() 函数中，创建了一个 RubberDuck 对象，并且通过 setFlyBehavior(new StrategyFlyFast()) 将飞行行为动态地改变为 StrategyFlyFast，让橡皮鸭可以飞。

与一般代码的区别：

• 动态行为改变：与传统代码不同，行为不再是硬编码在类中的，而是通过接口和具体实现类来定义的。这样，行为可以在运行时灵活改变，而不需要修改类本身的代码。
• 低耦合、高扩展：行为与具体的对象解耦（鸭子的飞行行为与鸭子类分离）。当需要新的飞行行为时，只需要实现 Strategy_Fly 接口，无需修改 Duck 类或其他地方的代码，符合“开闭原则”。
• 面向接口编程：鸭子类并不知道飞行行为的具体实现，只知道 Strategy_Fly 接口。通过这种方式，我们可以在不改变鸭子类的情况下，动态地给它赋予不同的飞行能力。