大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

动机

在软件构建过程中，我们需要为某些对象建立 一种“通知依赖关系” —-一个对象发(目标对象)的状态发生改变，所有依赖的对象(观察者对象)都将很好的得到通知。如果这样的依赖关系过于紧密。将使软件不能很好的抵御变化

使用面向对象技术 可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。

模式定义

定义对象间的一种一对多(变化)的依赖关系，以便当一个对象(subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新

实例

实现进度条

朴素实现

class MainForm : public Form{ 
   
    TextBox * txtFilaPath;
    TextBox * txtFileNumber;

    ProgressBar *progressBar;
public :
    void Button_Click(){ 
   
        string filePath = txtFilaPath->getText();
        int number = atoi(txtFileNumber->getText());

        FileSplitter splitter(filePath,number,progressBar);

        splitter.split();
    }
}

class FileSpliter{ 
   
    string m_filePath;
    int m_fileNumber;
    ProgressBar *m_progressBar;
public:
    FileSpliter(const string & filePath,int fileNumber,ProgressBar progressbar):
    m_filePath(filePath),
    m_fileNumber(fileNumber),
    m_progressBar(progressbar){ 
   
        
    }
    void split(){ 
   
        //1.读取大文件

        //2.分批向小文件写入
        for(int i = 0;i < m_fileNumber;i ++){ 
   
            //..
            if(m_progressBar != nullptr){ 
   
                m_progressBar->setValue((i + 1) / m_fileNumber);
            }
        }
    }
}

观察者模式实现

class MainForm : public Form, public IProgress{ 
   
    TextBox * txtFilaPath;
    TextBox * txtFileNumber;

    ProgressBar *progressBar;
public :
    void Button_Click(){ 
   
        string filePath = txtFilaPath->getText();
        int number = atoi(txtFileNumber->getText());

        FileSplitter splitter(filePath,number);
        ConsoleNotifier cn;

        splitter.addIProgress(this);
        splitter.addIProgress(this);
        
        splitter.split(&cn);
    }
    virtual void Doprogress(float value){ 
   
        progressBar->setValue(value);
    }
}

class ConsoleNotifier : public IProgress{ 
   
public:
    virtual void DoProgress(float value){ 
   
        cout<<".";
    }
}

//抽象接口
class IProgress{ 
   
    string m_filePath;
public:
    virtual void DoProgress(float value) = 0;
    virtual ~IProgress(){ 
   };
}

class FileSpliter{ 
   
    string m_filePath;
    int m_fileNumber;
    // ProgressBar *m_progressBar; //通知控件
    vector<IProgress *> m_iprogressVector;   //抽象通知机制


public:
    FileSpliter(const string& filePath,int fileNumber):
    m_filePath(filePath),
    m_fileNumber(fileNumber){ 
   
    }
    void add_IProgress(IProgress *iprogress){ 
   
        m_iprogressVector.push_back(iprogress);
    }
    void remove_IProgress(IProgress *iprogress){ 
   
        m_iprogressVector.remove(iprogress);
    }
    void add
    void split(){ 
   
        //1.读取大文件

        //2.分批向小文件写入
        for(int i = 0;i < m_fileNumber;i ++){ 
   
            //..
            float progressValue = (i + 1) / m_fileNumber;
            onProgress(progressValue);
        }
    }
protected:
    void onProgress(float value){ 
   
        vector<IProgress *>::Iterator itor = m_iprogressVector.begin();

        while(itor != m_iprogressList.end()){ 
   
            (*itor)->DoProgress(value); //更新进度条
            itor ++;
        }
    }
}

结构图

要点总结

• 使用面向对象的抽象，Obeserver模式使得我们可以独立改变目标与观察者，从而使两者之间的关系达到松耦合
• 目标发送通知时，无需指定观察者，通知(可以携带通知信息作为参数)会自动传播
• 观察者自己决定是否需要订阅通知，目标对象对此一无所知
• Obeserver 模式是基于事件UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分

笔记

• 违背了依赖倒置原则 高层不能依赖底层 高层和底层都应该依赖于抽象 抽线不能依赖实现 实现应该依赖抽象
• 依赖：指的是编译时依赖 A依赖B B必须存在 A才能通过编译
• 独立一般指 你变我不变 松耦合