策略模式：符合开闭原则，如果if else过多或者有待增加时宜使用，节省高级缓存指令空间占用

行为型设计模式，不同的创建型对象的具体行为

分析重构前的代码：

class Review {
 public:
  enum FoodType { CHINA, JAPAN };

 public:
  void isYummy() {
    if (type_ == FoodType::CHINA)
      ::printf("好吃\n");
    else if (type_ == FoodType::JAPAN)
      ::printf("美味しい\n");
  }

 private:
  FoodType type_;
};

上面的代码看似无可厚非，但是把时间轴拉长，如果后面需要加入对其他菜系的评价，就破坏了开闭原则。
首先需要在枚举中增加枚举，然后在方法中增加判断。

class Review {
 public:
  enum FoodType { CHINA, JAPAN, GERMANY };

 public:
  void isYummy() {
    if (type_ == FoodType::CHINA)
      ::printf("好吃\n");
    else if (type_ == FoodType::JAPAN)
      ::printf("美味しい\n");
    else if (type_ == FoodType::GERMANY)
      ::printf("Echt lecker\n");
  }

 private:
  FoodType type_;
};

接下来我们对代码进行重构：

class Review {
 public:
  Review(Food *food) : food_{food} {}

  void isYummy() { this->food_->taste(); }

 private:
  Food *food_;
};

class Food {
 public:
  virtual ~Food() {}

  virtual void taste() = 0;
};

class ChinaFood : public Food {
 public:
  ~ChinaFood() override {}
  void taste() override { ::printf("好吃\n"); }
};

class JapanFood : public Food {
 public:
  ~JapanFood() override {}
  void taste() override { ::printf("美味しい\n"); }
};

class GermanFood : public Food {
 public:
  ~GermanFood() override {}
  void taste() override { ::printf("Echt lecker\n"); }
};

class Review 就变得稳定。内部遵从了开闭原则，对于该类不再修改任何代码，体现了代码的复用性。
class Review 内部成员food_在运行时绑定了谁，是由外部传入的（这里一般使用工厂模式来构造Food的具体对象），实现了解耦，充分体现了单一职责。

类图：