观察者模式(Observer)

个人理解：

观察者模式的核心是Subject的Attach和Detach方法，加载Observer对象

UML类图：

代码实现：

    public abstract class Subject
    {
        protected List<Observer> observers=new List<Observer>();

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

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

        public void Notify()
        {
            foreach (var o in observers)
                o.Update();
        }
    }

    public abstract class Observer
    {
        public abstract void Update();
    }

    public class SubjectA : Subject
    {
        public int SubjectState { get; set; } //定义这个state只是为了同步更新ObserverA的state
    }

    public class ObserverA : Observer
    {
        public int ObserverState { get; set; }
        private SubjectA subject;

        public ObserverA(SubjectA subject)
        {
            this.subject = subject;
        }

        public override void Update()
        {
            this.ObserverState = this.subject.SubjectState;
            Console.WriteLine("Observer A was notified...");
        }
    }

 

Python代码实现:

class BaseSubject(object):
    __listeners=[]
    def Attach(self, listener):
        self.__listeners.append(listener)
    def Detach(self, listener):
        self.__listeners.remove(listener)
    def Invoke(self):
        for listener in self.__listeners:
            listener.Update()

class AbstractListener(object):
    def Update(self):
        raise NotImplementedError("abstract class")

class AnimalListener(object):
    words=""
    def Update(self):
        print("animal is saying " + self.words)

class PlantListener(object):
    actions=""
    def Update(self):
        print("plant is "+ self.actions +"ing");
if __name__ == "__main__":
    subject=BaseSubject()

    animal1=AnimalListener()
    animal1.words="haha"
    subject.Attach(animal1)

    plant1=PlantListener()
    plant1.actions="laugh"
    subject.Attach(plant1)

    subject.Invoke()