设计模式（五）————观察者模式（Observer Pattern）

定义：

在对象之间定义一对多的关系，这样一来，当一个对象改变状态，所有依赖他的对象都会收到通知，并自动更新。

(在此模式中，一个目标物件管理所有相依于它的观察者物件。并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的的方法来实现。观察者模式有时又被成为模型-视图（Model-View）模式，源-收听者（Listenr）模式或者从属模式)

UML类图：

C++实现：

#include<iostream>
#include<list>
using namespace std;

class Observer;
class Subject
{
public:
	virtual void registerObserver(Observer*) = 0;
	virtual void removeObserver(Observer*) = 0;
	virtual void notifyObserver() = 0;
	virtual ~Subject() = default;
};
class Observer
{
public:
	virtual void update() = 0;
	virtual ~Observer() = default;
};
class ConcreteSubject :public Subject
{
	list<Observer*> observers;
	int State;
public:
	// 通过 Subject 继承
	virtual void registerObserver(Observer* observer) override
	{
		this->observers.push_back(observer);
	}

	virtual void removeObserver(Observer * observer) override
	{
		this->observers.remove(observer);
	}

	virtual void notifyObserver() override
	{
		for (Observer* observer : observers)
		{
			observer->update();
		}
	}
	int getState()
	{
		return this->State;
	}
	void setState(int state)
	{
		this->State = state;
	}
	virtual ~ConcreteSubject() {}
};
class ConcreteObserver :public Observer
{
	Subject* subject;
public:
	ConcreteObserver(Subject* subject)
	{
		this->subject = subject;
	}
	// 通过 Observer 继承
	virtual void update() override
	{
		cout << "update excute" << endl;
	}
	virtual ~ConcreteObserver() {}
};
int main()
{
	ConcreteSubject* subject = new ConcreteSubject();
	ConcreteObserver* observer = new ConcreteObserver(subject);
	subject->registerObserver(observer);
	subject->notifyObserver();
	return 0;
}

C#实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using static System.Console;

namespace ConsoleApp1
{

    interface Subject
    {
        void registerObserver(Observer observer);
        void removeObserver(Observer observer);
        void notifyObserver();
    }
    interface Observer
    {
        void update();
    }
    class ConcreteSubject : Subject
    {
        List<Observer> observers=new List<Observer>();
        int State;
        public void notifyObserver()
        {
            foreach(Observer observer in observers)
            {
                observer.update();
            }
        }

        public void registerObserver(Observer observer)
        {
            observers.Add(observer);
        }

        public void removeObserver(Observer observer)
        {
            observers.Remove(observer);
        }

        public int getState()
        {
            return State;
        }
        public void setState(int State)
        {
            this.State = State;
            notifyObserver();
        }
    }
    class ConcreteObserver : Observer
    {
        Subject subject;
        public ConcreteObserver(Subject subject)
        {
            this.subject = subject;
        }
        public void update()
        {
            WriteLine("update excute");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject subject = new ConcreteSubject();
            ConcreteObserver observer = new ConcreteObserver(subject);
            subject.registerObserver(observer);
            subject.notifyObserver();
        }
    }
}