前言

大家好，我是 god23bin，今天我们来介绍下设计模式中的一个重要的设计模式——策略模式。

当涉及到某个行为或算法有多个变体时，策略模式是一种常见的设计模式。它允许在运行时选择使用不同的策略，而无需修改现有代码。

现在就使用设计模式中经常出现的鸭子模型来介绍吧！

鸭子模型

鸭子模型也是很好理解的，走路像鸭子，会像鸭子一样游泳，还会叫出类似嘎嘎嘎的声音的东西，就是鸭子模型，至于它是不是鸭子，这不重要！

策略模式

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。

主要解决在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护的问题。

在大学食堂中，有许多的菜品，那么我们设计一个食物 Food 接口来表示各种菜品，该接口需要具有一个能够展示各种食物是什么的能力，就设计成一个 show 方法吧。

public interface Food {
    void show();
}

每种食物菜品都能够展示，那么我们定义一个鸭脖策略类 DuckNeckStrategy，作为一个食物菜品的策略。这个类实现 Food 接口，重写了 show 方法，能够展示这是一道正儿八经的鸭脖。

public class DuckNeckStrategy implements Food {
    @Override
    public void show() {
        System.out.println("嘎嘎嘎，我是正儿八经的鸭脖。");
    }
}

接着，我们写一个食物策略类，该策略类也实现 Food 接口，并将食物 Food 接口作为该类的属性进行声明，这种称为组合。同时写一个带 Food 接口参数的构造方法。

public class FoodStrategy implements Food {
    private Food food;

    public FoodStrategy(Food food) {
        this.food = food;
    }

    @Override
    public void show() {
        food.show();
    }
}

现在，我们用餐的同学出场了，写一个 Student 类，定义一个吃正儿八经鸭脖的方法。

public class Student {

    // 吃正儿八经的鸭脖
    public void eatDuckNeck() {
        Food duckNeck = new FoodStrategy(new DuckNeckStrategy());
        System.out.println("开吃！");
        duckNeck.show();
    }

}

现在咱们运行下程序：

public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        student.eatDuckNeck();
    }
}

输出：

开吃！
嘎嘎嘎，我是正儿八经的鸭脖。

现在我们定义一个老鼠头策略类 MouseHeadStrategy，作为一道菜品策略，自然也是需要实现 Food 接口，重写了 show 方法，能够实现展示鼠头鸭脖这道菜品。

public class MouseHeadStrategy implements Food {
    @Override
    public void show() {
        System.out.println("吱吱吱，我是长得像鼠头的鸭脖。");
    }
}

接着，给咱们的同学加餐，多定义一个无奈吃鸭脖的方法，将一个老鼠头策略作为加餐的参数传递到方法中。

public class Student {

    // 吃正儿八经的鸭脖
    public void eatDuckNeck() {
        Food duckNeck = new FoodStrategy(new DuckNeck());
        System.out.println("开吃！");
        duckNeck.show();
    }
	
    // 吱吱吱，吃鸭脖
    public void eatDuckNeck(MouseHeadStrategy mouseHeadStrategy) {
        Food duckNeck = new FoodStrategy(mouseHeadStrategy);
        System.out.println("开吃！");
        duckNeck.show();
    }

}

现在，给 eatDuckNeck 方法传入一个老鼠头参数，咱们继续运行下程序。

public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        // 指鼠为鸭
        student.eatDuckNeck(new MouseHeadStrategy());
    }
}

输出：

开吃！
吱吱吱，我是长得像鼠头的鸭脖。

很明显，程序依旧能够执行，即使将鼠头传入，也能成为鸭脖。这就是策略模式给我们带来的好处，它允许我们在程序运行时去选择不同的算法或策略来实现某种功能，而无需改变已有的代码结构。提高了咱们代码的灵活性。

在这个例子中，策略模式可以在运行时通过策略来决定说你吃的是什么，想怎样就怎样，想让你是鸭脖就是鸭脖，即使你是老鼠头。

总结

策略模式的写法：

1. 定义共同的接口或抽象类来声明策略类都要实现的方法，就比如这里的 show 方法。
2. 定义具体的策略类，比如这里的 DuckNeckStrategy 和 MouseHeadStrategy，实现接口中的方法，每个具体策略类提供不同的算法或行为实现。
3. 定义客户端类，比如这里的 FoodStrategy，持有一个之前定义接口或抽象类的引用，这里也就是所谓的组合，同时实现接口，实现一个构造方法，用来使用不同的策略来执行重写的接口方法。
4. 在代码中使用这个客户端类，传入不同的策略到构造方法中来实现不同的效果。

本文灵感来源：https://www.bilibili.com/video/BV1jm4y1q76g

最后的最后

希望各位屏幕前的靓仔靓女们给个三连！你轻轻地点了个赞，那将在我的心里世界增添一颗明亮而耀眼的星！

咱们下期再见！