【设计模式】对象行为型模式

行为创建型模式

系列综述：
来源：该系列是主要参考《大话设计模式》和《设计模式(可复用面向对象软件的基础)》，其他详细知识点拷验来自于各大平台大佬的博客。
总结：汇总篇
如果对你有用，希望关注·点赞·收藏一波。

---

---

😊点此到文末惊喜↩︎

---

对象行为型模式

策略模式

1. 原则
   • 变化点是类封装的目标。
   • 封装是类划分的前提，类并不是越多越好。
   • 类划分的基础是抽象，是具有相同属性和功能的对象的抽象
2. 核心：通过switch选择相似行为的选择
3. 代码原理
   • 业务场景类：在具体的业务逻辑中封装算法族的多态调用
   • 抽象策略类：算法族的抽象接口
   • 具体策略类：算法族中具体的算法实现
     
4. 特点：
   • 破坏开闭原则。拓展产品需要修改原工厂内部的逻辑
   • 符合单一职责原则。将对象的创建逻辑和实现的业务逻辑进行了分离
5. 示例代码

// 抽象策略类
interface AbstarctStrategy{
    void algorithm();
}
// 具体策略类
class ConcreteStrategy1 implements AbstarctStrategy
{
    @Override
    public void algorithm()
    {
        System.out.println("具体策略1");
    }
}
class ConcreteStrategy2 implements AbstarctStrategy
{
    @Override
    public void algorithm()
    {
        System.out.println("具体策略2");
    }
}

// 业务场景类
class Context
{
    private AbstarctStrategy strategy;
    public void setStrategy(AbstarctStrategy strategy){
        this.strategy = strategy;
    }
	// 核心：对于算法的多态调用
    public void algorithm(){
        strategy.algorithm();
    }
}

// 调用
Context context = new Context();
context.setStrategy(new ConcreteStrategy1());
context.algorithm();
context.setStrategy(new ConcreteStrategy2());
context.algorithm();

---

Observer观察者模式

1. 定义
   • 当对象间存在一对多的依赖关系时，即当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。
2. 构成
   • 被观察者/主体 接口（SubjectInterface）：提供增加、移除和通知观察对象列表的接口
   • 观察者接口（ObserverInterface）：提供观察者对象的一个更新操作接口，方便主体通过观察者队列进行调用
   • 具体 被观察者/主体（ConcreteSubject）：继承主体接口，维护观察者列表，并在状态发生改变时通知观察者。
   • 具体观察者（ConcreteObserver）：具体观察者是观察者的具体实现类。实现了更新方法，定义了在收到主体通知时需要执行的具体操作。
3. 优点：
   • S符合单一职责原则：将观察者和被观察者解耦，使得它们可以独立变化而互不影响。
   • O符合开放封闭原则：增删观察者，只需要通过具体主体的操作即可
4. 缺点：
   • 广播链的问题：如果一个观察者有双重身份，既是观察者，也是被观察者，会导致环链逻辑，增加系统复杂度。
   • 异步处理问题：如果观察者比较多，而且处理时间比较长需要考虑异步的线程安全问题
   • 被观察者频繁变化：会导致观察者频繁接收通知，出现系统性能问题
   • 观察者模式会增加代码的复杂性，因为需要处理观察者和被观察者之间的关系以及通知的实现细节。
5. 代码示例

// 很好的unique_ptr对类对象使用的示例
#include <iostream>
#include <vector>
#include <algorithm>
#include <memory>
// 观察者 接口
class ObserverInterface{
public:
    virtual void dosomething()=0;
    virtual ~ObserverInterface(){} // 虚基类必须有虚析构函数
};
// 被观察者/主体 接口
// 类似于typedef对类型的别名定义，使用unique_ptr能自动释放，无需delete
using UniqueObserverInterface = std::unique_ptr<ObserverInterface>;
class SubjectInterface{
public:
    virtual void Add(UniqueObserverInterface obr) = 0;
    virtual void Remove(UniqueObserverInterface obr) = 0;
    virtual void Notify()=0;
    virtual ~SubjectInterface(){} // 虚基类必须有虚析构函数
};
// 具体被观察者
class Me:public SubjectInterface{
public:
	// 增加观察者
    void Add(UniqueObserverInterface obr) override{
        observers.emplace_back(std::move(obr));
    }
	// 移除观察者
    void Remove(UniqueObserverInterface obr) override{
        auto pos = std::find(observers.begin(),observers.end(),obr);
        if(pos != observers.end()){
            observers.erase(pos);
        }
    }
	// 通知所有观察者
    void Notify() override{
        for(const auto& obs : observers){
            obs->dosomething();
        }
    }
private:
	// 观察者队列
    std::vector<UniqueObserverInterface > observers;
};

// 具体观察者1：妻子
class Wife:public ObserverInterface{
public:
    void dosomething() override{
        std::cout<<"老公快回来了，开始做饭"<<std::endl;
    }
};
// 具体观察者2：儿子
class Son:public  ObserverInterface{
public:
    void dosomething() override {
        std::cout<<"爸爸快回来了，不能玩游戏了"<<std::endl;
    }
};


int main(){
    Me me;
    UniqueObserverInterface wife=std::make_unique<Wife>();
    UniqueObserverInterface son=std::make_unique<Son>();
    me.Add(std::move(wife));
    me.Add(std::move(son));
    //下班了 发消息
    me.Notify();
    // 不主要delete，智能指针会自动释放
}

---

少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。 秘籍（点击图中书籍）·有缘·赠予你

---

🚩点此跳转到首行↩︎

参考博客

1. 菜鸟教程-单例模式
2. 观察者模式（c++学习笔记）
3. 待定引用
4. 待定引用
5. 待定引用
6. 待定引用
7. 待定引用
8. 待定引用