策略模式实战：通过组合实现算法的灵活解耦

如果继续用继承，我必须在每个子类里重写 Hibernation 和 ClimbTree 方法。如果有 100 种不冬眠的熊，就要写 100 遍'不冬眠'的逻辑。基类中的通用行为反而成了束缚，导致代码复用性急剧下降。

1.2 设计原则的思考

这时候需要回归设计原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

既然'怎么爬树'和'怎么冬眠'是会变的，那就把它们踢出 Bear 类，单独封装！我要把'行为'变成一种'零件'，哪只熊需要什么零件，组装上去就行了。这就是组合优于继承的思想。

二、重构方案：策略模式

为了代码整洁，我们专注于重构 Hibernation 和 ClimbTree 这两个变化点。

2.1 抽象行为接口

首先，将'怎么冬眠'抽象成一个接口族，定义统一的契约。

class Hibernation_Behavior {
public:
    virtual void Hibernation() = 0;
};

class Hibernation_able : public Hibernation_Behavior {
public:
    void Hibernation() override {
        std::cout << "进行冬眠" << std::endl;
    }
};

class Hibernation_unable : public Hibernation_Behavior {
public:
    void Hibernation() override {
        std::cout << "不需要冬眠" << std::endl;
    }
};

同理，把爬树能力也拆分出来。

class ClimbTree_Behavior {
public:
    virtual void ClimbTree() = 0;
};

class ClimbTree_able : public ClimbTree_Behavior {
public:
    void ClimbTree() override {
        std::cout << "会爬树" << std::endl;
    }
};

class ClimbTree_unable : public ClimbTree_Behavior {
public:
    void ClimbTree() override {
        std::cout << "不需要爬树" << std::endl;
    }
};

2.2 重构上下文类

现在，Bear 类不再亲自负责实现具体的动作，它只负责拥有一个'行为'的指针。具体怎么执行，委托给持有的策略对象。

class Bear {
public:
    // 构造函数注入策略
    Bear(std::shared_ptr<Hibernation_Behavior> hibernation, 
         std::shared_ptr<ClimbTree_Behavior> climb) 
        : hibernation_behavior_(hibernation), climbTree_behavior_(climb) {}

    void Hibernation() {
        if (hibernation_behavior_) {
            hibernation_behavior_->Hibernation();
        }
    }

    void ClimbTree() {
        if (climbTree_behavior_) {
            climbTree_behavior_->ClimbTree();
        }
    }

protected:
    std::shared_ptr<Hibernation_Behavior> hibernation_behavior_;
    std::shared_ptr<ClimbTree_Behavior> climbTree_behavior_;
};

2.3 具体角色实现

各种熊的实现变得非常清晰，只需在构造时装配相应的行为组件。

class BrownBear : public Bear {
public:
    BrownBear() 
        : Bear(std::make_shared<Hibernation_able>(), 
               std::make_shared<ClimbTree_able>()) {}
};

class Panda : public Bear {
public:
    Panda() 
        : Bear(std::make_shared<Hibernation_able>(), 
               std::make_shared<ClimbTree_able>()) {}
};

class ToyBear : public Bear {
public:
    ToyBear() 
        : Bear(std::make_shared<Hibernation_unable>(), 
               std::make_shared<ClimbTree_unable>()) {}
};

三、总结

这就是传说中的策略模式（Strategy Pattern）。

通过把 Hibernation_Behavior 和 ClimbTree_Behavior 定义为算法族，我们将行为的实现与使用行为的 Bear 类彻底解耦。

核心优势：

1. 复用性提升：如果不冬眠的代码逻辑变了，只需要改 Hibernation_unable 这一个类，所有不冬眠的熊都会自动更新。
2. 扩展性无敌：如果需要加个'机械熊'会火箭跳跃，只需要新写一个 RocketJump_Behavior，然后在机械熊里装配上就行，根本不用去动原来的代码。

定义回顾：定义一系列算法族，分别封装起来，让它们之间可互相替换，此模式让算法的变化独立于使用算法的客户。

在实际开发中，当面临多个相似类但行为差异较大，或者行为频繁变动时，优先考虑策略模式而非继承，往往能让架构更加健壮。