观察者模式observer不适用于,观察者模式observer适用于

　　观察者模式：定义一对多的依赖关系，允许多个观察者对象同时监听某个主题对象。当这个subject对象的状态发生变化时，它会通知所有的observer对象，以便它们可以自动更新自己。

　　UML类图：

　　分析：

　　Observer类，抽象observer，为所有具体的observer定义了一个接口，并在收到主题通知时进行自我更新。这个接口叫做更新接口。抽象观察器通常由抽象类或接口实现。一个更新接口通常包含一个更新方法，称为更新方法。

　　Subject类，可以翻译成subject或者抽象通知器，一般是通过抽象类或者接口实现的。它将所有对观察者对象的引用保存在一个集合中，每个主题可以有任意数量的观察者。抽象主题提供了添加和删除观察者对象的接口。

　　ConcreteSubject类称为特定主题或特定通知器，将相关状态存储到特定的观察者对象中：当特定主题的内部状态发生变化时，通知所有注册的观察者。特定的主题通常用特定的子类来实现。

　　ConcreteObserver类，具体观察者，实现抽象观察者角色所需的更新接口。以便使其自身的状态与主题的状态相协调。特定的观察者角色可以保存对特定主题对象的引用，特定的观察者角色通常由特定的子类实现。

　　观察者模式的实现：

　　/*

　　*observer类，抽象Observer，为所有具体的Observer定义了一个接口，并在得到主题通知时进行自我更新。

　　*这个接口称为更新接口。抽象观察器通常由抽象类或接口实现。更新接口通常包含一个

　　*Update方法，这种方法叫做Update方法。

　　*/

　　抽象类观察者

　　{

　　publicatabstractvoidupdate()；

　　}

　　/*

　　*Subject类，可以翻译为Subject或abstract notifier，一般由抽象类或接口实现。

　　*它将所有对观察者对象的引用保存在一个集合中，每个主题可以有任意数量的观察者。

　　*抽象主题提供了添加和删除观察者对象的接口。

　　*/

　　abstractclassSubject

　　{

　　私人观察员=新观察员

　　//添加观察者

　　publicfoidatch(Observerobserver)

　　{

　　观察者。添加(观察员)；

　　}

　　//移除观察者

　　publicviddetach(Observerobserver)

　　{

　　观察者。移除(观察者)；

　　}

　　//通知

　　publicvoidNotify()

　　{

　　foreach(Observeroinobservers)

　　{

　　o.update()；//通知每个观察者，以便每个观察者可以修改自己的状态。

　　}

　　}

　　}

　　/*

　　*ConcreteSubject类被称为特定主体或特定通知者，并将相关状态存储到特定观察者对象中：

　　*当特定主题的内部状态改变时，通知所有注册的观察者。特定主题通常

　　*用具体的子类实现。

　　*/

　　classConcreteSubject:主题

　　{

　　privatestringsubjectState

　　publicstringgetSubjectState()

　　{

　　return this . subject state；

　　}

　　publicvidsetsubjectstate(string state)

　　{

　　this.subjectState=state

　　}

　　}

　　/*

　　*ConcreteObserver类，具体的观察者，实现抽象观察者角色所需的更新接口。为了让自己

　　* 的状态与主题的状态一致。特定观察者角色可以保存对特定主题对象的引用，特别是

　　*观察者角色通常由特定的子类实现。

　　*/

　　classConcreteObserver:观察者

　　{

　　privatestringname

　　privatestringobserverState

　　privatecoconcretesubjectcsubject；

　　public concrete observer(concrete subject subject，stringname)

　　{

　　this . c subject=c subject；

　　this.name=name

　　}

　　public concrete subject getcsubject()

　　{

　　return this . c subject；

　　}

　　publicvoidsetCSubject(具体主题主题)

　　{

　　this . c subject=c subject；

　　}

　　publicoverridevoidUpdate()

　　{

　　this . observer state=this . c subject . get subject state()；

　　控制台。WriteLine(观察者{0}的状态为{1} ，this.name，this . observer state)；

　　//thrownewNotImplementedException()；

　　}

　　}

　　}

　　{

　　concrete subject subject=new concrete subject()；

　　主题。attach(new concrete observer(c subject， X ))；

　　主题。attach(new concrete observer(c subject， Y ))；

　　主题。attach(new concrete observer(c subject， Z ))；

　　c subject . set subject state( ABC )；

　　主题。notify()；

　　控制台。read()；

　　}

　　}

　　}

　　我们知道，把一个系统分成一系列相互合作的类，有一个很不好的副作用，就是需要维护相关对象之间的一致性。我们不想为了保持一致性而将各种紧密耦合，这样会给维护、扩展和重用带来不便。观察者模式的关键对象是主体和观察者。一个主题可以有任意数量的依赖于它的观察者。一旦对象的状态发生变化，所有观察者都会得到通知。主体发送通知时，不需要知道它的观察者是谁，也就是不需要知道具体的观察者是谁。而任何特定的观察者都不知道也不需要知道其他观察者的存在。

　　当一个对象的改变需要同时改变其他对象，并且不知道要改变多少个对象时，就要考虑观察者模式了。

　　一般来说，观察者模式做的其实就是解耦。让耦合双方依靠抽象而不是具体。以便每个更改都不会影响另一端的更改。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。