设计模式-策略模式的完整代码示例及测试验证

策略模式

什么是策略模式？

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换。
策略模式使得算法可以在不影响客户端的情况下发生变化。策略模式主要解决的是在有多种算法相似的情况下，使用if…else或者switch…case来选择具体算法的问题。

策略模式构成

策略接口：定义了所有支持的算法的公共接口。
具体策略类：实现了策略接口，封装了具体的算法。
上下文类：使用一个具体策略来完成所要的行为。

优缺点

优点

易于扩展：增加新算法时，只需要新增具体策略类，不需要修改已有的代码，符合开闭原则。
消除冗长的条件判断语句：通过策略类的替换，避免了大量的if…else或switch…case语句。

缺点

客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
增加了系统中类的数量，每个具体策略都会产生一个新的类。

与工厂模式的区别

关注点不同：
1. 策略模式：
  
  关注的是行为的替换和变化。通过策略模式，可以在运行时改变行为，而不需要修改客户端代码。强调的是行为的选择和变化，而不是对象的创建。
2. 工厂模式：
  
  关注的是对象的创建和实例化。通过工厂模式，可以将对象的创建过程封装起来，从而让客户端代码不依赖具体的类。强调的是创建产品对象的过程
结构不同
1. 策略模式：
  
  包含一个上下文类（Context），多个策略接口（Strategy），以及策略接口的具体实现类（ConcreteStrategy）。
  客户端通常会持有一个上下文对象，并在上下文对象中设置或传递具体的策略对象。
2. 工厂模式:
  包含一个工厂接口（或抽象类），具体工厂类（ConcreteFactory），以及创建的产品类（Product）。
  工厂模式有几种变体，如简单工厂、工厂方法和抽象工厂。不同的变体有不同的结构和用法。

策略模式正篇

之所以这个章节才称为正篇，是因为上面的一堆总结并不能真正让人理解策略模式，除非你已经很懂策略模式了。
接下来我希望用更简单的方式，用说人话的方式来讲清楚什么是策略模式。
故事要从朋友的一句话说起，策略模式不就是高级的if-else嘛。

知识点回顾

要弄清楚策略模式的本质，其实还是要回到最开始学习java面向对象的时候，万物皆对象，面向对象的三大特征：封装、继承、多态。

场景案例

继续请出工厂模式中的牛马们来举例。
现在有猫、狗、2种动物，都被圈养在动物园中，他们各自的介绍方式都不一样，但是都用腿走两步，在动物园我们可以召唤猫、狗、来观看他们自我介绍和走的行为

案例UML类图

Abstract抽象类

1，动物父类(Animal)

由于猫、狗、是动物，有相同地走的行为，所以可以抽象出一个Abstract Animal动物类，然后让猫、狗继承这个动物类。
因为走的行为是相同的，所以在父类中直接进行了方法的具体实现，而自我介绍的方式各不一样，所以定义了一个抽象的方法，由子类去具体实现。


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:06
 * @Description: 动物类：别总牛马牛马的称呼，人家学名叫动物
 */
public abstract class Animal {

   /**
    * @Author: javafa
    * @Description: 每种动物 都要进自我介绍，由子类去具体实现
    * @Date: 2024/7/31 16:10
    * @Param:
    * @return: void
    **/
   public abstract void speak();

   /**
    * @Author: javafa
    * @Description: 所有动物都有相同的行为特征：走两步
    * @Date: 2024/7/31 16:09
    * @Param:
    * @return: void
    **/
   public void walk() {
      System.out.println("没事儿走两步");
   }

}

2，具体动物实现类

猫—喵喵喵

/**
 * @Author: javafa
 * @Date: 2024/7/31 16:24
 * @Description: 动物-猫
 */
public class Cat extends Animal{
    @Override
    public void speak() {
        System.out.println("喵新人说：喵喵喵！");
    }
}

狗—旺旺旺


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:24
 * @Description: 动物-大黄狗
 */
public class Dog extends Animal{
    /**
     * @Author: javafa
     * @Description: 旺财说
     * @Date: 2024/7/31 16:38
     * @Param:
     * @return: void
    **/
    @Override
    public void speak() {
        System.out.println("旺财说：汪汪汪！");
    }
}

3，动物园

动物园里可以通过动物类型来召唤任何一种动物，去观察自我介绍和走两步的行为。


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:04
 * @Description: 牛马们所在的动物园
 */
public class Zoo {

   Animal animal;//动物父类

   /**
    * @Author: javafa
    * @Description: 通过动物类型，来召唤(实例化)不同的动物
    * @Date: 2024/7/31 17:19
    * @Param: animalType
    * @return:
    **/
   public Zoo(String animalType) {
      if (animalType.equals("dog")) {
         animal = new Dog();
      } else if (animalType.equals("cat")) {
         animal = new Cat();
      }
   }

   /**
    * @Author: javafa
    * @Description: 查看动物的行为
    * @Date: 2024/7/31 17:22
    * @Param:
    * @return: void
    **/
   public void show() {
      animal.speak();
      animal.walk();
   }

}

4，调用测试


/**
 * @Author: javafa
 * @Description: 调用测试：查看动物园动物的行为
 * @Date: 2024/7/31 17:24
 * @Param:
 * @return: void
 **/
@Test
public void ZooShowTest(){
   //看看喵星人
   Zoo zoo = new Zoo("cat");
   zoo.show();
}

运行结果：

在这里插入图片描述

总结下，我们定义了抽象类Animal，然后定义了2个具体的猫(Cat)、狗(Dog)、继承Animal类，将相同的行为 走两步(walk) 在父类中直接实现，
而不同方式的自我介绍(speak)定义为抽象abstract方法，由子类去具体实现。

如果动物园中又来了牛啊，马啊，在Zoo中继续添加if-else就行了，如果来100个动物呢，

修改100次？——> 就修改100次，写100个if-else，代码很清晰。
那违反了开闭原则？——> 原则也不是必须的，代码很健壮

直到动物园来了一个团宠，小海豚，他只能游两步，没法走两步了，当然也简单，让海豚继承Animal后，我们可以体现多态性去重写Animal的walk方法。

小海豚

/**
 * @Author: javafa
 * @Date: 2024/8/1 10:26
 * @Description: 动物-小海豚
 */
public class Dolphin extends Animal{

   @Override
   public void speak() {
      System.out.println("我是小海豚，我会海豚音！");
   }

   @Override
   public void walk() {
      System.out.println("我是小海豚，我不会走两步，我可以游两步！");
   }
}

扩展Zoo


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:04
 * @Description: 牛马们所在的动物园
 */
public class Zoo {

    Animal animal;//动物父类

    /**
     * @Author: javafa
     * @Description: 通过动物类型，来召唤(实例化)不同的动物
     * @Date: 2024/7/31 17:19
     * @Param: animalType
     * @return:
     **/
    public Zoo(String animalType) {
        if (animalType.equals("dog")) {
            animal = new Dog();
        } else if (animalType.equals("cat")) {
            animal = new Cat();
        } else if (animalType.equals("dolphin")){
            animal = new Dolphin();
        }
    }

    /**
     * @Author: javafa
     * @Description: 查看动物的行为
     * @Date: 2024/7/31 17:22
     * @Param:
     * @return: void
     **/
    public void show() {
        animal.speak();
        animal.walk();
    }

}

调用测试


import com.fivemillion.algorithm.designpatterns.strategy.case2.Zoo;
import org.junit.jupiter.api.Test;

/**
 * @Author: javafa
 * @Date: 2024/7/30 16:04
 * @Description: 调用测试
 */
public class StrategyTest {

   /**
    * @Author: javafa
    * @Description: 调用测试：查看动物园动物的行为
    * @Date: 2024/7/31 17:24
    * @Param:
    * @return: void
    **/
   @Test
   public void ZooShowTest(){
      //看看小海豚
      Zoo zoo = new Zoo("dolphin");
      zoo.show();
   }

}

运行结果：

我们通过重写walk方法，成功解决了团宠-小海豚不能走两步的问题，如果动物园又来了小蜜蜂封，他也不能走两步，他只能飞两步，我们还得重写walk方法，
随着小动物的增多，和行为的增多，代码里全是没法共用的重写，显然通过继承没法解决这个问题了。

总结一下继承Animal带来的问题

对于walk这种行为，如果定义抽象方法，那么像猫、狗等有相同走两步的动物，也要去实现walk，并且代码是相同的，就会导致大量重复代码，无法复用。
如果在父类中定义具体实现，具有不同行为的动物自己去重写，如小海豚，小蜜蜂，小海星，会导致大量的重写，而且小海豚，小海豹，小海狮他们的走两步都是通过
游的方式，这部分重复的行为代码又无法复用。
如果我们继续增加一个吐泡泡的行为，那么父类Animal和所有的子类都要进行修改，即使有些动物并不能完成这个行为。

Interface接口

接下来看看java中接口如何解决这个问题。如果我们把走两步的行为抽象成接口Walk，那么对于猫、狗就可以实现这个接口，而小海豚不用实现这个接口。
把吐泡泡的行为抽象成接口Bubble，那么只有拥有吐泡泡行为能力小海豚来实现这个接口，以后来了小海狮也可以实现这个接口，而其他动物没有这个能力就不用实现了。

接口方式UML类图

Walk接口

定义走的接口方法

/**
 * @Author: javafa
 * @Date: 2024/8/1 13:24
 * @Description: 走的接口
 */
public interface Walk {
    /**
     * @Author: javafa
     * @Description: 走两步的方法
     * @Date: 2024/8/1 13:25
     * @Param:
     * @return: void
    **/
    void walk();
}

Bubble接口

定义吐泡泡的接口方法


/**
 * @Author: javafa
 * @Date: 2024/8/1 13:24
 * @Description: 吐泡泡的接口
 */
public interface Bubble {
    /**
     * @Author: javafa
     * @Description: 吐泡泡的方法
     * @Date: 2024/8/1 13:25
     * @Param:
     * @return: void
     **/
    void bubble();
}

Animal抽象类

只保留所有动物都有的自我介绍的speak抽象方法


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:06
 * @Description: 动物类：别总牛马牛马的称呼，人家学名叫动物
 */
public abstract class Animal {

    /**
     * @Author: javafa
     * @Description: 每种动物 都要进自我介绍，由子类去具体实现
     * @Date: 2024/7/31 16:10
     * @Param:
     * @return: void
     **/
    public abstract void speak();


}

Dog类

继承Animal抽象类实现speak方法，实现Walk接口的walk方法


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:24
 * @Description: 动物-大黄狗
 */
public class Dog extends Animal implements Walk{
    /**
     * @Author: zhaozuofa
     * @Description: 旺财说
     * @Date: 2024/7/31 16:38
     * @Param:
     * @return: void
    **/
    @Override
    public void speak() {
        System.out.println("旺财说：汪汪汪！");
    }

    @Override
    public void walk() {
        System.out.println("没事儿走两步");
    }
}

Cat类

继承Animal抽象类实现speak方法，实现Walk接口的walk方法


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:24
 * @Description: 动物-猫
 */
public class Cat extends Animal implements Walk{
    @Override
    public void speak() {
        System.out.println("喵新人说：喵喵喵！");
    }

    @Override
    public void walk() {
        System.out.println("没事儿走两步");
    }
}

Dolphin类

继承Animal抽象类实现speak方法，实现Bubble接口的bubble方法


/**
 * @Author: javafa
 * @Date: 2024/8/1 10:26
 * @Description: 动物-小海豚
 */
public class Dolphin extends Animal implements Bubble{

    @Override
    public void speak() {
        System.out.println("我是小海豚，我会海豚音！");
    }


    @Override
    public void bubble() {
        System.out.println("我是小海豚，我会吐泡泡！");
    }
}

Zoo类

/**
 * @Author: javafa
 * @Date: 2024/7/31 16:04
 * @Description: 牛马们所在的动物园
 */
public class Zoo {

    Animal animal;//动物父类

    /**
     * @Author: javafa
     * @Description: 通过动物类型，来召唤(实例化)不同的动物
     * @Date: 2024/7/31 17:19
     * @Param: animalType
     * @return:
     **/
    public Zoo(String animalType) {
        if (animalType.equals("dog")) {
            animal = new Dog();
        } else if (animalType.equals("cat")) {
            animal = new Cat();
        } else if (animalType.equals("dolphin")){
            animal = new Dolphin();
        }
    }

    /**
     * @Author: javafa
     * @Description: 查看动物的行为
     * @Date: 2024/7/31 17:22
     * @Param:
     * @return: void
     **/
    public void show() {
        animal.speak();
        if(animal instanceof Dolphin){
            //有请小海豚表演
            Dolphin dolphin = (Dolphin) animal;
            dolphin.bubble();//小海豚吐泡泡
        }
    }

}

调用测试

欣赏小海豚的表演

import com.fivemillion.algorithm.designpatterns.strategy.case3.Zoo;
import org.junit.jupiter.api.Test;

/**
 * @Author: javafa
 * @Date: 2024/7/30 16:04
 * @Description: 调用测试
 */
public class StrategyTest {

    /**
     * @Author: javafa
     * @Description: 调用测试：查看动物园动物的行为
     * @Date: 2024/7/31 17:24
     * @Param:
     * @return: void
    **/
    @Test
    public void ZooShowTest(){
        //看看小海豚
        Zoo zoo = new Zoo("dolphin");
        zoo.show();
    }

}

运行结果

总结一下，我们虽然将自我介绍speak、走两步walk、吐泡泡bubble等行为，通过继承和实现给隔离分开，保证了没有某种行为的动物不必去拥有这项行为，如小海豚
不再走两步walk，阿猫阿狗不再吐泡泡bubble。但是对于walk接口来说，阿猫，阿狗走两步的行为是相同的，如果后续动物园来了100个动物也都是有走两步的行为，
我们就得写100次walk方法，导致这些代码无法复用，如果walk方法突然增加了一个参数，我们就要修改100个地方，继承中的问题仍然没有被解决。

导致我们如此纠结的本质原因是，对于walk来说，这是个不确定的行为，有的动物有，有的动物没有，甚至走两步也有不同的方式，有的动物用2条腿走，
有的动物用4条腿走，有的动物用8条腿走，万幸的是策略模式刚好可以解决这个问题。

策略模式

我们再来读一遍策略模式的定义：策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换。
策略模式使得算法可以在不影响客户端的情况下发生变化。

回顾下设计原则核心思想

针对接口编程，而不是针对实现编程。
将应用中可能需要变化的代码和不需要变化的代码分开独立。
都是为了交互对象间解耦合而操心。

针对接口编程，而不是针对实现编程，核心在于Animal类，walk走的行为应该作为一个Animal的变量，当然这个变量可以是接口Interface，也可以是抽象类Abstract，
实现了Animal类的子类，可以动态的选择为这个变量赋值去实现某个行为，如狗类中，就可以赋值4条腿去走，猫类中就可以赋值2条腿去走，小海豚就可以赋值不走，而走两步walk
和具体几条腿走就是策略模式的定义中被称为的“一些列算法”之一的算法，我们的赋值就是所谓的“互换”。这样就能使子类不是只绑定死某个接口或抽象类。

走两步的UML类图

针对Walk走两步的接口，我们进行了具体的实现，NonLegsWalk(没腿走)、TwoLegsWalk(2条腿走)、FourLegsWalk(4条腿走)，如果后续有动物8条腿走，100条腿走
我们都可以达到灵活扩展，并且不会影响已有的实现。

Walk接口


/**
 * @Author: javafa
 * @Date: 2024/8/1 13:24
 * @Description: 走的接口
 */
public interface Walk {
    /**
     * @Author: javafa
     * @Description: 走两步的方法
     * @Date: 2024/8/1 13:25
     * @Param:
     * @return: void
    **/
    void walk();
}

没有腿走路-NonLegsWalk

/**
 * @Author: javafa
 * @Date: 2024/8/1 16:11
 * @Description: 走两步的具体实现类-没有腿走路
 */
public class NonLegsWalk implements Walk{

    @Override
    public void walk() {
        System.out.println("我没腿，我不走路！");
    }
}

2条腿走路-TwoLegsWalk


/**
 * @Author: javafa
 * @Date: 2024/8/1 16:11
 * @Description: 走两步的具体实现类-2条腿走路
 */
public class TwoLegsWalk implements Walk{

    @Override
    public void walk() {
        System.out.println("我用2条腿走路！");
    }
}

4条腿走路-FourLegsWalk


/**
 * @Author: javafa
 * @Date: 2024/8/1 16:11
 * @Description: 走两步的具体实现类-4条腿走路
 */
public class FourLegsWalk implements Walk{

    @Override
    public void walk() {
        System.out.println("我用4条腿走路！");
    }
}

Animal

Animal中我们将走两步的行为Walk被声明为接口类型的变量，在构造函数中初始化，由子类选择具体地走两步的实现方式，即接口的最终实现类


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:06
 * @Description: 动物类：别总牛马牛马的称呼，人家学名叫动物
 */
public abstract class Animal {

    //走两步的行为被声明为接口类型的变量，在构造函数中初始化，由子类选择具体的走两步的实现方式，即接口的最终实现类
    public Walk walkObj;

    /**
     * @Author: javafa
     * @Description: 由子类去具体选择用什么方式进行走两步
     * @Date: 2024/8/1 16:41
     * @Param: walkImpl
     * @return:
    **/
    Animal(Walk walkImpl){
        this.walkObj = walkImpl;
    }

    protected Animal() {
    }

    /**
     * @Author: javafa
     * @Description: 每种动物 都要进自我介绍，由子类去具体实现
     * @Date: 2024/7/31 16:10
     * @Param:
     * @return: void
     **/
    public abstract void speak();

    /**
     * @Author: zhaozuofa
     * @Description: 实现walk方法，具体是由2条腿，4条腿等哪种walk实现来调用，依赖构造中的walkImpl具体实现
     * @Date: 2024/8/1 17:06
     * @Param:
     * @return: void
    **/
    public void walk(){
        if(walkObj != null){
            walkObj.walk();
        }
    }
}

Dolphin-小海豚

小海豚不会走两步，我们看Dolphin怎么做，其实什么也不做，对于Animal中接口类型的walk变量，子类不具备走两步的行为，不理会就行了，你怎么修改都对我没影响


/**
 * @Author: javafa
 * @Date: 2024/8/1 10:26
 * @Description: 动物-小海豚
 */
public class Dolphin extends Animal implements Bubble {

    @Override
    public void speak() {
        System.out.println("我是小海豚，我会海豚音！");
    }


    @Override
    public void bubble() {
        System.out.println("我是小海豚，我会吐泡泡！");
    }
}

动物园-Zoo

动物园中我们可以正常展示动物的行为，自我介绍和走两步

/**
 * @Author: javafa
 * @Date: 2024/7/31 16:04
 * @Description: 牛马们所在的动物园
 */
public class Zoo {

    Animal animal;//动物父类

    /**
     * @Author: javafa
     * @Description: 通过动物类型，来召唤(实例化)不同的动物
     * @Date: 2024/7/31 17:19
     * @Param: animalType
     * @return:
     **/
    public Zoo(String animalType) {
        if (animalType.equals("dog")) {
            animal = new Dog();
        } else if (animalType.equals("cat")) {
            animal = new Cat();
        } else if (animalType.equals("dolphin")){
            animal = new Dolphin();
        }
    }

    /**
     * @Author: javafa
     * @Description: 查看动物的行为
     * @Date: 2024/7/31 17:22
     * @Param:
     * @return: void
     **/
    public void show() {
        animal.speak();
        animal.walk();
    }

}

调用示例

import com.fivemillion.algorithm.designpatterns.strategy.case4.Zoo;
import org.junit.jupiter.api.Test;

/**
 * @Author: javafa
 * @Date: 2024/7/30 16:04
 * @Description: 调用测试
 */
public class StrategyTest {

    /**
     * @Author: javafa
     * @Description: 调用测试：查看动物园动物的行为
     * @Date: 2024/7/31 17:24
     * @Param:
     * @return: void
    **/
    @Test
    public void ZooShowTest(){
        //看看小海豚
        Zoo zoo = new Zoo("dolphin");
        zoo.show();
    }

}

执行结果
虽然在动物园的show()方法中，我们任然调用了animal.walk(); 但是由于Dolphin中我们并没有为父类的的Animal的walkObj变量赋值，
所以Dolphin中walk()方法中，walkObj为null，所以不会调用walk()方法，所以不会走两步。

在这里插入图片描述

当然我们也可以通过为父类的walkObj变量赋值，来让Dolphin走两步，因为我们强大到预判了这类没腿的动物，预留了NonLegsWalk类，只需要稍稍修改Dolphin


/**
 * @Author: javafa
 * @Date: 2024/8/1 10:26
 * @Description: 动物-小海豚
 */
public class Dolphin extends Animal implements Bubble {

    
    public Dolphin() {
        //实现小海豚走两步的行为
        walkObj = new NonLegsWalk();
    }

    @Override
    public void speak() {
        System.out.println("我是小海豚，我会海豚音！");
    }


    @Override
    public void bubble() {
        System.out.println("我是小海豚，我会吐泡泡！");
    }
}

运行结果

在这里插入图片描述

有一天，小海豚苦练走两步的技能，用他的鳍也可以走起来了，这时我们希望能动态的设置走两步，而不是在Dolphin的构造中写死走两步的实现类，其实也很简单，
为Animal的walkObj变量提供一个set方法，让外部可以去动态的设置走两步的实现类就行了

Animal


/**
 * @Author: javafa
 * @Date: 2024/7/31 16:06
 * @Description: 动物类：别总牛马牛马的称呼，人家学名叫动物
 */
public abstract class Animal {


    //走两步的行为被声明为接口类型的变量，在构造函数中初始化，由子类选择具体的走两步的实现方式，即接口的最终实现类
    public Walk walkObj;

    //提供set方法，可以更灵活的动态设置走两步的实现
    public void setWalkObj(Walk walkObj) {
        this.walkObj = walkObj;
    }

    /**
     * @Author: javafa
     * @Description: 由子类去具体选择用什么方式进行走两步
     * @Date: 2024/8/1 16:41
     * @Param: walkImpl
     * @return:
    **/
    Animal(Walk walkImpl){
        this.walkObj = walkImpl;
    }

    protected Animal() {
    }

    /**
     * @Author: javafa
     * @Description: 每种动物 都要进自我介绍，由子类去具体实现
     * @Date: 2024/7/31 16:10
     * @Param:
     * @return: void
     **/
    public abstract void speak();

    /**
     * @Author: zhaozuofa
     * @Description: 实现walk方法，具体是由2条腿，4条腿等哪种walk实现来调用，依赖构造中的walkImpl具体实现
     * @Date: 2024/8/1 17:06
     * @Param:
     * @return: void
    **/
    public void walk(){
        if(walkObj != null){
            walkObj.walk();
        }
    }
}



/**
 * @Author: javafa
 * @Date: 2024/7/31 16:04
 * @Description: 牛马们所在的动物园
 */
public class Zoo {

    Animal animal;//动物父类

    /**
     * @Author: javafa
     * @Description: 通过动物类型，来召唤(实例化)不同的动物
     * @Date: 2024/7/31 17:19
     * @Param: animalType
     * @return:
     **/
    public Zoo(String animalType) {
        if (animalType.equals("dog")) {
            animal = new Dog();
        } else if (animalType.equals("cat")) {
            animal = new Cat();
        } else if (animalType.equals("dolphin")){
            animal = new Dolphin();
        }
    }

    /**
     * @Author: javafa
     * @Description: 查看动物的行为
     * @Date: 2024/7/31 17:22
     * @Param:
     * @return: void
     **/
    public void show() {
        animal.speak();
        //为小海豚动态设置走两步的方式-2条腿走
        animal.setWalkObj(new TwoLegsWalk());
        animal.walk();
    }

}

运行结果

在这里插入图片描述

至此，策略模式已成，再次思考起开头朋友的总结“策略模式就是高级的if-else”,现在用装的话可以说，是也不是。相同点都是在面对不确定性的情况下，进行判断的抉择，
不同点是if-else更像是写好的人生剧本，因果注定。策略模式则是一种思想，面向接口编程而不是实现，他为每一种变化都提供一个入口，种一个种子，至于怎么
实现则完全由你，看到if-else你仿佛一眼看到生命的尽头，而看到策略模式仿佛看到了我命由我不由天的自由。