【面向对象设计模式】揭秘经典模式，提升编程思维与实战能力

引言

面向对象设计模式是软件工程领域中一套经过验证的解决方案，旨在解决常见的设计问题。通过学习和应用这些模式，开发者可以提升编程思维，提高代码的可读性、可维护性和可扩展性。本文将揭秘经典的设计模式，并探讨如何在实战中应用它们。

创建型模式

创建型模式关注对象的创建过程，主要目的是将对象的创建与使用解耦。以下是几种常见的创建型模式：

工厂模式（Factory Method）

工厂模式定义了一个接口，让子类决定实例化哪一个具体类。这种模式让客户端代码和具体类解耦，增加了系统的灵活性。

class Product {
public:
    virtual void operation() = 0;
};

class ConcreteProductA : public Product {
public:
    void operation() override {
        // 实现具体操作
    }
};

class ConcreteProductB : public Product {
public:
    void operation() override {
        // 实现具体操作
    }
};

class Factory {
public:
    static Product* createProduct(int type) {
        switch (type) {
            case 1:
                return new ConcreteProductA();
            case 2:
                return new ConcreteProductB();
            default:
                return nullptr;
        }
    }
};

单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供全局访问点。这种模式在需要全局访问某个特定对象时非常有用。

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

建造者模式（Builder）

建造者模式将构造过程与它的表示分离，使得同样的构建过程可以有不同的表示。这种模式适用于构建复杂对象，并支持可选配置。

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual Product* getResult() = 0;
};

class ConcreteBuilder : public Builder {
public:
    void buildPartA() override {
        // 构建部分A
    }
    void buildPartB() override {
        // 构建部分B
    }
    Product* getResult() override {
        return new Product();
    }
};

class Director {
public:
    void construct(Builder* builder) {
        builder->buildPartA();
        builder->buildPartB();
    }
};

结构型模式

结构型模式主要关注对象组合和协作，将类和对象组合成更大的结构。以下是几种常见的结构型模式：

适配器模式（Adapter）

适配器模式使一个接口匹配另一个接口，以便于调用者无需知道细节。

class Target {
public:
    virtual void request() = 0;
};

class Adaptee {
public:
    void specificRequest() {
        // 实现特定请求
    }
};

class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}
    void request() override {
        adaptee->specificRequest();
    }
};

装饰者模式（Decorator）

装饰者模式动态地给对象添加职责，可以独立增加功能，而不影响其他对象。

class Component {
public:
    virtual void operation() = 0;
};

class ConcreteComponent : public Component {
public:
    void operation() override {
        // 实现具体操作
    }
};

class Decorator : public Component {
protected:
    Component* component;
public:
    Decorator(Component* component) : component(component) {}
    void operation() override {
        component->operation();
    }
};

class ConcreteDecoratorA : public Decorator {
public:
    void operation() override {
        // 实现装饰者A的具体操作
        Component::operation();
        // 添加新的操作
    }
};

行为模式

行为模式关注对象之间的交互方式，主要目的是应对需求变化为多个交互的类带来的冲击。以下是几种常见的行为模式：

策略模式（Strategy）

策略模式定义一系列算法，并将每个算法封装起来，使它们可以互相替换。

class Strategy {
public:
    virtual void algorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void algorithmInterface() override {
        // 实现策略A的具体算法
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void algorithmInterface() override {
        // 实现策略B的具体算法
    }
};

class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* strategy) : strategy(strategy) {}
    void setStrategy(Strategy* strategy) {
        this->strategy = strategy;
    }
    void executeAlgorithm() {
        strategy->algorithmInterface();
    }
};

观察者模式（Observer）

观察者模式定义对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

class Observer {
public:
    virtual void update() = 0;
};

class ConcreteObserverA : public Observer {
public:
    void update() override {
        // 实现观察者A的更新操作
    }
};

class ConcreteObserverB : public Observer {
public:
    void update() override {
        // 实现观察者B的更新操作
    }
};

class Subject {
private:
    std::vector<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    void notify() {
        for (Observer* observer : observers) {
            observer->update();
        }
    }
};

总结

通过学习和应用面向对象设计模式，开发者可以提升编程思维，提高代码的质量。本文介绍了经典的设计模式，包括创建型、结构型和行为模式，并通过示例代码展示了如何在实战中应用它们。希望这些内容能帮助读者更好地理解和掌握面向对象设计模式。

引言