观察者模式又称为____模式

关于观察者模式说法正确的是

A 观察者模式也叫做发布/订阅模式

B 是MVC模式的重要组成部分

C 复用性强

D 对象之间实名通信

B.结构式观察法

[说明]

在一公文处理系统中，开发者定义了一个公文结构OfficeDoc，其中定义了公文应该具有的属性(字段)。当公文的内容或状态发生变化时，与之相关联的DocExplorer结构的值都需要发生改变。一个OfficeDoc结构能够关联一组DocExplorer结构。当OfficeDoc结构的内容或状态发生变化时，所有与之相关联的DocExplorer结构都将被更新，这种应用被称为观察者模式。以下代码采用C语言实现，能够正确编译通过。

[C代码]

include ＜stdio.h＞

define OBS_MAXNUM 20 /*一个OfficeDoc变量最多能够关联的*/

/*DoeExplorer变量的个数*/

typedef void((1))(struct OfficeDoc*,street DocExplorer*);

struct DocExplorer{

func update;/* DocExplorer结构采用的更新函数*/

/*其他的结构字段省略*/

};

struct OfficeDoc{

(2) myObs[OBS_MAXNUM];

/*存储所有与OfficeDoc相关联的DoeExplorer结构指针*/

int index;/*与OfficeDoc结构变量相关联的DocExplorer结构变量的个数*/

};

void attach(struet OfficeDoc *doc, struet DocExplorer *ob){

/*关联Obersver结构ob与OfficeDoe结构doc*/

int loop=0;

if(doc-＞index ＞=OBS_MAXNUM || b==NULL) return;

for(loop=0; loop ＜doc-＞index; loop++)

if(doc-＞myObs[loop]==ob)return;

doc-＞myObs[doe-＞index]=ob;

doc-＞index++;

)

void detach(struct OfficeDoc *doc, struct DocExplorer *ob){

/*解除doc结构与ob结构间的关系*/

int loop;

if(ob==NULL)return;

for(loop=0; loop ＜doc-＞index; loop6++){

if(doc-＞myObs[loop]==ob){

if(loop＜=doc-＞index-2)

doe-＞myObs[loop]=doc-＞myObs[ (3) ];

doc-＞myObs[doe-＞indox-1]=NULL;

doe-＞index--;

break;

}

}

}

void updatel(struct OfficeDoc *doc,struct DocExplorer *ob){

/*更新ob结构的值，更新代码省略*/

}

void update2(stmct OfficeDoc *doc, struct DocExplorer *ob){

/*更新ob结构的值，更新代码省略*/

}

void notifyObs(struet OfficeDoc *doc){

/*当doc结构的值发生变化时，通知与之关联的所有DocExplorer结构变量*/

int loop;

for(loop=0; loop ＜doc-＞index; loop++){

(doc-＞myObs[loop])-＞update((4));

}

}

void main(){

stmct OfficeDoc doc;/*定义一OfficeDoc变量*/

struct DocExplorer explorer1, explorer2;/*定义两个DocExplorer变量*/

/*初始化与OfficeDoc变量相关的DocExplorer变量个数为0*/

doc.index=0;

explorer1.update=update1;/*设置explorer1变量的更新函数*/

explorer2.update=update2;/*设置explorer2变量的更新函数*/

attaeh(&doc,&explorer1);/*关联explorer1与doc对象*/

attach(&doc,&explorer2);/*关联explorer2与doc对象*/

/*其他代码省略*/

(5);/*通知与OfficeDoc相关的所有DocExplorer变量*/

return;

}

[说明]

在一公文处理系统中，开发者定义了一个公文类OfficeDoc，其中定义了公文具有的属性和处理公文的相应方法。当公文的内容或状态发生变化时，关注此OfficeDoc类对象的相应的DocExplorer对象都要更新其自身的状态。一个OfficeDoc对象能够关联一组 DocExplorer对象。当OfficeDoc对象的内容或状态发生变化时，所有与之相关联的 DocExplorer对象都将得到通知，这种应用被称为观察者模式。以下代码采用Java语言实现，能够正确编译通过。

[Java代码]

//Subject.java 文件

public interface Subject {

public void attach(Observer DocExplorer);

public void detach(Observer DocExplorer);

void notifyObservers();

}

//Observer.java 文件

public interface Observer{

void update((1) );

}

//OfficeDoc.java 文件

import java.util.*;

public class OfficeDoc implements Subject(//OfficeDoc 类实现 Subject 接口

private Vector bserverVeetor=new java.util.Vector();

//存储与OfficeDoc相关联的DocExplorer 对象

public void attach(Observer observer){

//将某 DocExplorer 对象与OfficeDoc 相关联

ObserverVector.addElement(observer);

}

public void detach(Observer observer){

//解除某DocExplorer 对象与OfficeDoc的关联关系

ObserverVector.removeElement(observer);

}

public void notifyObservers(){

//当OfficeDoc对象状态已发生变化时，通知所有的DocExplorer对象

Enumeration enumeration=(2);

while (enumeration.hasMoreElements()){

((Observer)enumeration.nextElement()).(3);

}

}

public Enumeration Observers(){

return ObserverVector.elements();

}

//其他公文类的属性和方法省略

}

//DoeExplorer.java 文件

public class DocExplorer implements (4) {

public void update( (5) ){

//更新DocExplorer自身的状态，代码省略

}

}

[说明]

在一公文处理系统中，开发者定义了一个公文类OfficeDoc，其中定义了公文具有的属性和处理公文的相应方法。当公文的内容或状态发生变化时，关注此OfficeDoc类对象的相应的DocExplorer对象都要更新其自身的状态。一个OfficeDoc对象能够关联一组 DocExplorer对象。当OfficeDoc对象的内容或状态发生变化时，所有与之相关联的 DocExplorcr对象都将得到通知，这种应用被称为观察者模式。以下代码写在一个C++源文件中，能够正确编译通过。

[C++代码]

include ＜iostream＞

const OBS_MAXNUM=20;//最多与OfficeDoc对象相关联的DocExplorer对象的个数

(1);

class DocExplorer{ //关注OfficeDoc公文对象的类

public:

DocExplorer( (2) *doc); //构造函数

(3) void update(OfficeDoc *doc)=0;//更新自身状态的函数

//其他相关属性和方法省略

};

class OfficeDoc{ //公文类

private:

DocExplorer *myObs[OBS_MAXNUM];

//关注此公文类的DocExplorer类对象指针数组

int index; //与OfficeDoc对象关联的DocExplorer对象的个数

public:

OfficeDoe()

index=0;

}

void attach(DocExplorer *o){

//将一DoeExplorer对象与OfficeDoe对象相关联

if(index ＞=OBS_MAXNUM ||o=NULL)return;

for(int loop=0; loop＜index; loop++)

if(myObs[loop]==o) return;

myObs[index]=o;

index++;

}

void detaeh(DocExplorer *o){

//接触某DoeExplorer对象与OfficeDoc对象的关联

if(0==NULL) return;

for(int loop=0; loop＜index; loop++){

if(myObs[loop]==o){

if(loop＜=index-2)myObs[loop]=myObs[index-1];

myObs[index-1]=NULL;

index--;

break;

}

}

}

private:

void notifyObs(){ //通知所有的DocExplorer对象更改自身状态

for(int loop=0; loop＜index; loop++){

myObs[loop]-＞(4); //DocExplorer对象更新自身状态

}

}

//其他公文类的相关属性和方法

};

DocExplorer::DocExplorer(OfficeDoc *doc){//DocExplorer 类对象的构造函数

doc-＞(5); //将此DocExplorer对象与doc对象相关联

}

【说明】

在一公文处理系统中，开发者定义了一个公文结构OfficeDoc，其中定义了公文应该具有的属性。当公文的内容或状态发生变化时，与之相关联的DocExplorer结构的值都需要发生改变。一个OfficeDoc结构能够关联一组DocExplorer结构。当OfficeDoc结构的内容或状态发生变化时，所有与之相关联的DocExplorer结构都将被更新，这种应用被称为观察者模式。以下代码采用C语言实现，能够正确编译通过。

【代码13-4】

include＜stdio.h＞

define OBS_MAXNUM 20 /*一个OfficeDoc变量最多能够关联的DocExplorer变量的个数*/

typedef void( (1) )(struc OffieeDoc*, struct DoeExplorer*)I;

struct DocExplorer{

func update;/*DocExplorer结构采用的更新函数*/

/*其它的结构字段省略*/

};

struet OffieeDoc{

(2) myObs[OBS_MAXNUM];

/*存储所有与OfficeDoc相关联的DocExplorer结构指针*/

int index;/*与OffieeDoc结构变量相关联的DoeExplorer结构变量的个数*/

}；

void attaeh(struct OfficeDoc*doc, struct DocExplorer*ob){

/*关联Observer结构ob与OffieeDoe结构doe*/

int loop=0;

if(doc-＞index＞=OBS_MAXNUM｜｜ob==NULL)return;

for(loop=0, loop＜doc-＞index; loop++)

if(doc-＞myObs[loop]==ob)return;

doc-＞myObs[doe-＞index]=ob；

doc-＞index++;

}

void detaeh(struct OfficeDoc*doc, struct DocExplorer*ob){

/*解除doc结构与ob结构间的关联*/

int loop;

if(ob==NULL)return;

for(loop=0;loop＜doc-＞index; loop++){

if(doe-＞myObs[loop]==ob){

if(loop＜=doc-＞index-2)

doc-＞myObs[loop]=doc-＞myObs[(3)];

doc-＞myObs[doc-＞index-1]=NULL;

doc-＞index——;

breack;

}

}

}

void updatel(struct OfficeDoe*doe, struct DoeExplorer *ob){

/*更新ob结构的值，更新代码省略*/

} void update2(struct OffieeDoc*doc,struet DocExplorer *ob){

/*更新ob结构的值，更新代码省略*/

}

void notifyObs(struct OfficeDoc* doc){

/*当doc结构的值发生变化时，通知与之关联的所有DocExplorer结构变量*/

int loop;

for(loop=0; loop＜doc-＞index; loop++){

(doc-＞myObs[loop])-＞update((4));

}

}

void main(){

struct OfficeDoc doc; /*定义一了OfficeDoe变量*/

struct DocExplorer explorer1, explorer2; /*定义两个DocExplorer变量*/

/*初始化与OfficeDoc变量相关的DocExplorer变量个数为0*/

doc.index=0;

explorer1.update=update1; /*设置explorer1变量的更新函数*/

explorer2. update=update2; /*设置explorer2变量的更新函数*/

attach(&doc, &explorer1); /*关联explorer1与doc对象*/

attach(&doc, &explorer2); /*关联explorer2与doc对象*/

/*其它代码省略*/

(5); /*通知与OfficeDoe相关的所有DoeExploer变量*/

return;

}

[说明]

在一公文处理系统中，开发者定义了一个公文类OfficeDoc，其中定义了公文具有的属性和处理公文的相应方法。当公文件中内容或状态发生变化时，关注此OfficeDoc类对象的相应的DocExplorer对象都要更新其自身的状态。一个OfficeDoc对象能够关联一组DocExplorer对象。当OfficeDoc对象的内容或状态发生变化时，所有与之相关联的DocExplorer对象都将得到通知，这种应用被称为Observer(观察者)模式。以下代码采用C++语言实现，能够正确编译通过。

[C++代码]

[说明]

在一公文处理系统中，开发者定义了一个公文类OfficeDoc，其中定义了公文具有的属性和处理公文的相应方法。当公文件的内容或状态发生变化时，关注此OfficeDoc类对象的相应的DocExplorer对象都要更新其自身的状态。一个OfficeDoc对象能够关联一组DocExplorer对象。当OfficeDoc对象的内容或状态发生变化时，所有与之相关联的DocExplorer对象都将得到通知，这种应用被称为Observer(观察者)模式。以下代码采用Java语言实现，能够正确编译通过。

[Java代码]

A.观察值与其预测值间的差异称为「残差」。

B.残差值愈小表示回归模式的解释能力愈强。

C.最小平方法也就是最小化残差值平方和的方法。

D.以上皆是。

A.观察者（Observer）模式，也叫发布/订阅（Publish/SubscribE.模式。

B.是MVC（模型-视图-控制器）模式的重要组成部分。

C.复用性强。

D.对象之间实名通信。