设计模式4-模版方法

重构获得模式

设计模式的目的是应对变化，提高复用

设计模式的要点是寻找变化点，然后在变化点处应用设计模式。从而更好地应对需求的变化。什么时候什么地点应用设计模式。比设计模式结构本身更为重要。
设计模式的应用，不应当先入为主，一上来就套用设计模式这是设计模式的最大误用，没有一步到位的设计。敏捷软件开发实践提倡的是refacroring to Patterns(重构), 是目前普遍公认的最好使用的设计模式的方法。

推荐书籍

重构的关键技法

让变化可配置
重构是改善现有代码设计的过程，通过一系列的技术手法和策略，使得代码更易于理解、扩展和维护。以下是几种重构的关键技法，以及它们在代码中的应用示例：

1. 静态转动态

技法说明：

• 将在编译时确定的部分改为在运行时确定，增加代码的灵活性和适应性。

示例：

• 将硬编码的条件判断改为通过配置文件或者用户输入来确定。

// 静态
bool isFeatureEnabled() {
    return true;  // 静态确定特性总是启用
}

// 动态
bool isFeatureEnabled() {
    // 通过配置文件或者用户输入来确定特性是否启用
    return config.isEnabled("featureX");
}

2. 早绑定转晚绑定

技法说明：

• 将函数调用的绑定从编译时确定延迟到运行时，使得对象能够在运行时选择调用不同的方法或策略。

示例：

• 使用虚函数和多态来实现晚绑定，而不是通过静态绑定的方式。

// 早绑定
class Shape {
public:
    void draw() {
        // 绘制代码
    }
};

// 晚绑定
class Shape {
public:
    virtual void draw() {
        // 绘制代码
    }
};

class Circle : public Shape {
public:
    void draw() override {
        // 绘制圆形的代码
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        // 绘制矩形的代码
    }
};

void render(Shape* shape) {
    shape->draw();  // 晚绑定，根据实际对象类型调用对应的draw方法
}

3. 继承转组合

技法说明：

• 通过组合现有类的实例来代替继承，以减少类之间的耦合性，同时提高代码的灵活性和可维护性。

示例：

• 将继承关系改为对象组合关系。

// 继承
class Car {
public:
    virtual void drive() {
        // 驾驶汽车
    }
};

class SportsCar : public Car {
public:
    void drive() override {
        // 驾驶运动汽车
    }
};

// 组合
class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class Car {
private:
    Engine engine;

public:
    void drive() {
        engine.start();
        // 驾驶汽车
    }
};

class SportsCar {
private:
    Engine engine;

public:
    void drive() {
        engine.start();
        // 驾驶运动汽车
    }
};

4. 编译时依赖转运行时依赖

技法说明：

• 将程序依赖关系从编译时硬编码转为运行时根据条件动态确定，提高程序的灵活性和可配置性

示例：

• 使用依赖注入或者配置来动态确定依赖。

// 编译时依赖
class Database {
public:
    void saveData(const std::string& data) {
        // 保存数据到 MySQL 数据库
    }
};

// 运行时依赖
class Database {
public:
    virtual void saveData(const std::string& data) = 0;
};

class MySQLDatabase : public Database {
public:
    void saveData(const std::string& data) override {
        // 保存数据到 MySQL 数据库
    }
};

class PostgresDatabase : public Database {
public:
    void saveData(const std::string& data) override {
        // 保存数据到 PostgreSQL 数据库
    }
};

void saveData(Database* db, const std::string& data) {
    db->saveData(data);  // 根据运行时传入的数据库对象调用相应的方法
}

5. 紧耦合转松耦合

技法说明：

• 减少模块或者类之间的依赖关系，使得各个模块之间可以独立开发、测试和部署。

示例：

• 使用依赖注入、接口抽象等手段降低模块间的耦合度。

// 紧耦合
class ServiceA {
public:
    void doSomething() {
        ServiceB b;
        b.doSomethingElse();
    }
};

class ServiceB {
public:
    void doSomethingElse() {
        // 实现
    }
};

// 松耦合
class ServiceB {
public:
    void doSomethingElse() {
        // 实现
    }
};

class ServiceA {
private:
    ServiceB& b;

public:
    ServiceA(ServiceB& b) : b(b) {}

    void doSomething() {
        b.doSomethingElse();
    }
};

通过这些关键技法，可以更好地进行代码重构，改进现有设计，使得代码更易于维护、扩展和重用，同时提高系统的灵活性和可靠性。

组件协助

定义：现代软件分专业分工之后的第一个结果是框架与应用的区分组建协作模式，通过完绑定来实现框架与应用间的松耦合是二者之间协作时常用的模式。

典型模式
• Template Method
• Observer / Event
• Strategy

动机

在软件构建过程中，每一项任务它常常有稳定的整体操作结构。但各个子步骤却有很多变化的需求。或者由于固定的原因，比如框架与应用之间的关系。而无法和任务的整体结构同时实现。
如何在确定稳定操作结构的前提下，来灵活应对各个子步骤的变化或者晚七实现需求？

结构化软件设计流程

面向对象软件设计流程

早绑定与晚绑定

模式定义

定义一个操作中的算法框架（稳定），而将一些步骤延迟（变化）到子类中template Method 使得子类可以不改变。一个算法的结构即可重新定义就是重写该算法的某些特定步骤。

结构

要点总结。

模板方法模式是一种非常基础性的设计模式。在面向对象系统中有着大量的应用。他用最简洁的机制也就是虚函数的多态性。为很多应用程序架构提供了灵活的扩展点。是代码复用方面的基本实现结构

除了可以灵活应对自步骤的变化以外，不要调用我，让我来调用你。反向控制结构是模板方法的典型应用。

在具体实验方面，被模板方法调用的虚方法可以具有实现，也可以没有任何实现。也就是所谓的抽象方法和纯虚方法。但一般推荐将他们设置为保护方法

例子

Template Method（模板方法）模式是一种行为设计模式，定义了一个操作中的算法的框架，将一些步骤推迟到子类中实现。这种模式是通过创建一个模板方法，该方法在一个算法的结构中定义了算法的骨架，而将一些步骤的实现延迟到子类中。

以下是一个简单的 C++ 示例，演示了模板方法模式的实现：

#include <iostream>

// 抽象基类
class AbstractClass {
public:
    // 模板方法，定义了算法的骨架
    void templateMethod() {
        operation1();
        commonOperation(); // 模板方法中可以包含具体实现
        operation2();
        if (hookMethod()) { // 钩子方法，可选覆盖
            optionalOperation();
        }
    }

protected:
    // 纯虚函数，需要在子类中实现
    virtual void operation1() = 0;
    virtual void operation2() = 0;

    // 具体方法，子类共享的实现
    void commonOperation() {
        std::cout << "AbstractClass: commonOperation" << std::endl;
    }

    // 钩子方法，可选覆盖
    virtual bool hookMethod() {
        return true; // 默认实现
    }

    // 可选的具体方法，子类可以选择性地覆盖
    virtual void optionalOperation() {
        std::cout << "AbstractClass: optionalOperation" << std::endl;
    }
};

// 具体子类实现
class ConcreteClass1 : public AbstractClass {
protected:
    void operation1() override {
        std::cout << "ConcreteClass1: operation1" << std::endl;
    }

    void operation2() override {
        std::cout << "ConcreteClass1: operation2" << std::endl;
    }

    bool hookMethod() override {
        std::cout << "ConcreteClass1: hookMethod" << std::endl;
        return false; // 覆盖钩子方法
    }
};

// 另一个具体子类
class ConcreteClass2 : public AbstractClass {
protected:
    void operation1() override {
        std::cout << "ConcreteClass2: operation1" << std::endl;
    }

    void operation2() override {
        std::cout << "ConcreteClass2: operation2" << std::endl;
    }

    // 这里没有覆盖钩子方法
};

// 客户端代码
int main() {
    AbstractClass* object1 = new ConcreteClass1();
    AbstractClass* object2 = new ConcreteClass2();

    // 调用模板方法，执行算法
    object1->templateMethod();
    std::cout << std::endl;
    object2->templateMethod();

    delete object1;
    delete object2;

    return 0;
}

示例解释：

1. AbstractClass 是抽象基类，定义了模板方法 templateMethod() 和一些具体方法 commonOperation()、optionalOperation()，以及一个钩子方法 hookMethod()。

2. ConcreteClass1 和 ConcreteClass2 是具体子类，分别实现了抽象类中的纯虚函数 operation1() 和 operation2()，并选择性地覆盖了钩子方法 hookMethod()。

3. 在客户端代码中，创建了 ConcreteClass1 和 ConcreteClass2 的对象，并调用它们的 templateMethod() 方法，执行了定义好的算法。

4. 输出结果展示了每个步骤的执行顺序，包括了钩子方法的选择性覆盖情况。

这个例子展示了模板方法模式的核心思想：定义一个算法的骨架，将特定的步骤延迟到子类中去实现，从而在不同的子类中实现算法的不同部分，同时保持算法结构的稳定性。