第1题:
试题五(共15分)
阅读下列说明和C++代码,将应填入(n)处的字句写在答题纸的对应栏内。
【说明】
某大型商场内安装了多个简易的纸巾售卖机,自动出售2元钱一包的纸巾,且每次仅售出一包纸巾。纸巾售卖机的状态图如图5-1所示。
采用状态( State)模式来实现该纸巾售卖机,得到如图5-2所示的类图。其中类State为抽象类,定义了投币、退币、出纸巾等方法接口。类SoldState、SoldOutState、NoQuarterState和HasQuarterState分别对应图5-1中纸巾售卖机的4种状态:售出纸巾、纸巾售完、没有投币、有2元钱。
【C++代码】
include<iostream>
using namespace std;
∥以下为类的定义部分
class TissueMachine; //类的提前引用
class State{
public:
virtual void insertQuarter()=0; //投币
virtual void ejectQuarter()=0; //退币
virtual void turnCrank()=0; //按下“出纸巾”按钮
virtual void dispense()=0; //出纸巾
};
/*类SoldOutState. NoQuarterState. HasQuarterState. SoldState的定义省略,每个类中均定义了私有数据成员TissueMachine* tissueMachine;*/
class TissueMachine{
private:
(1) *soldOutState, *noQuarterState, *hasQuarterState,*soldState, *state;
int count, //纸巾数
public:
TissueMachine(int numbers);
void setState(State* state);
State* getHasQuarterState();
State* getNoQuarterState();
State* getSoldState();
State* getSoldOutState();
int getCount();
//其余代码省略
};
//以下为类的实现部分
void NoQuarterState::insertQuarter(){
tissueMachine->setState( (2) );
}
void HasQuarterState::ejectQuarter(){
tissueMachine->setState( (3) );
}
void SoldState::dispense(){
if(tissueMachine->getCount()>0){
tissueMachine->setState ( (4) );
}
else{
tissueMachine->setState( (5) );
}
}//其余代码省略
(1) State
(2) tissueMachine->getHasQuarterState()或new HasQuarterState
(3) tissueMachine->getNoQuarterState()或new NoQuarterState
(4) tissueMachine->getNoQuarterState()或new NoQuarterState
(5) tissueMachine->getSoldOutState()或new SoldOutState
第2题:
阅读以下技术说明及C++代码,将C++程序中(1)~(5)空缺处的语句填写完整。
[说明]
在一公文处理系统中,开发者定义了一个公文类OfficeDoc,其中定义了公文具有的属性和处理公文的相应方法。当公文件中内容或状态发生变化时,关注此OfficeDoc类对象的相应的DocExplorer对象都要更新其自身的状态。一个OfficeDoc对象能够关联一组DocExplorer对象。当OfficeDoc对象的内容或状态发生变化时,所有与之相关联的DocExplorer对象都将得到通知,这种应用被称为Observer(观察者)模式。以下代码采用C++语言实现,能够正确编译通过。
[C++代码]
第3题:
阅读以下说明和Java代码,将应填入(n)处。
[说明]
在一公文处理系统中,开发者定义了一个公文类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自身的状态,代码省略
}
}
第4题:
阅读以下说明和C代码(代码13-4),将应填入(n)处的字句写在对应栏内。
【说明】
在一公文处理系统中,开发者定义了一个公文结构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;
}
第5题:
阅读以下说明和C代码,将应填入(n)处。
[说明]
在一公文处理系统中,开发者定义了一个公文结构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;
}
第6题:
阅读下列说明和c++代码,将应填入(n)处的字句写在答题纸的对应栏内。
【说明】
某软件公司现欲开发一款飞机飞行模拟系统,该系统主要模拟不同种类飞机的飞行特征与起飞特征。需要模拟的飞机种类及其特征如表5-l所示。
为支持将来模拟更多种类的飞机,采用策略设计模式(Strategy)设计的类图如图5—1所示。
图5-l中,AirCraft为抽象类,描述了抽象的飞机,而类Helicopter、AirPlane、Fighter和Harrier分别描述具体的飞机种类,方法fly( )和takeOff( )分别表示不同飞机都具有飞行特征和起飞特征;类FlyBehavior与TakeOffBehavior为抽象类,分别用于表示抽象的飞行行为与起飞行为;类SubSonicFly与SuperSonicFly分别捕述亚音速飞行和超音速飞行的行为;类Verti calTakeOff与LongDistanceTakeoff分别描述垂直起飞与长距离起飞的行为。
【C++代码】
include
using namespace std;
class FlyBehavior{
public:virtual void fly( )=0;
};
class SubSonicFly:public FlyBehavior{
public: void fly( ){cout<<"亚音速飞行! "<
第7题:
阅读以下技术说明及Java代码,将Java程序中(1)~(5)空缺处的语句填写完整。
[说明]
在一公文处理系统中,开发者定义了一个公文类OfficeDoc,其中定义了公文具有的属性和处理公文的相应方法。当公文件的内容或状态发生变化时,关注此OfficeDoc类对象的相应的DocExplorer对象都要更新其自身的状态。一个OfficeDoc对象能够关联一组DocExplorer对象。当OfficeDoc对象的内容或状态发生变化时,所有与之相关联的DocExplorer对象都将得到通知,这种应用被称为Observer(观察者)模式。以下代码采用Java语言实现,能够正确编译通过。
[Java代码]
第8题:
阅读以下说明和C++代码,将应填入(n)处。
[说明]
在一公文处理系统中,开发者定义了一个公文类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对象相关联
}
第9题:
阅读以下说明和JAVA 2代码,将应填入(n)处的字句写在对应栏内。
[说明]
以下程序为类类型的变量应用实例,通过异常处理检验了类CCircle的变量的合法性,即参数半径应为非负值。仔细阅读代码和相关注释,将程序补充完整。
[JAVA代码]
//定义自己的异常类
class CCircleException extends Exception
{
}
// 定义类 CCircle
class CCircle
{
private double radius;
public void setRadius ( double r ) (1)
{
if ( r<0 ) {
(2)
}
else
(3)
}
Public void show ( ) {
System. out. println ( "area="+3.14*radius*radius );
}
}
public class ciusample
{
public static void main ( String args[] )
{
CCircle cir=new CCircle( );
(4) {
cir. setRadius ( -2.0 )
}
(5)
{
System. out. println ( e+" throwed" ) ;
}
cir. show( ) ;
}
}
第10题:
阅读下列说明和Java代码,将应填入 (n)处的字句卸载答题纸的对应栏内. 【说明】 某实验室欲建立一个实验室环境监测系统,能够显示实验室的温度、湿度以及洁净度等环境数据。当获取到最新的环境测量数据时,显示的环境数据能够更新。 现在采用观察者(Observer)模式来开发该系统。观察者模式的类图如图6-1所示。
【Java代码】 import java.util.*; interface Observer { public void update(float temp, float humidity, float cleanness); } interface Subject { public void registerObserver(Observer o); //注册对主题感兴趣的观察者 public void removeObserver(Observer o); //删除观察者 public void notifyObservers(); //当主题发生变化时通知观察者 } class EnvironmentData implements (1) { private ArrayList observers; private float temperature, humidity, cleanness; public EnvironmentData() { observers = new ArrayList(); } public void registerObserver(Observer o) { observers.add(o); } public void removeObserver(Observer o) { /* 代码省略 */ } public void notifyObservers() { for (int i = 0; i < observers.size(); i++) { Observer observer = (Observer)observers.get(i); (2) ; } } public void measurementsChanged() { (3) ; } public void setMeasurements(float temperature, float humidity, float cleanness) { this.temperature = temperature; this.humidity = humidity; this.cleanness = cleanness; (4) ; } } class CurrentConditionsDisplay implements (5) { private float temperature; private float humidity; private float cleanness; private Subject envData; public CurrentConditionsDisplay(Subject envData) { this.envData = envData; (6) ; } public void update(float temperature, float humidity, float cleanness) { this.temperature = temperature; this.humidity = humidity; this.cleanness = cleanness; display(); } public void display() {/* 代码省略 */ } } class EnvironmentMonitor{ public static void main(String[] args) { EnvironmentData envData = new EnvironmentData(); CurrentConditionsDisplay currentDisplay = new CnrrentConditionsDisplay(envData); envData.setMeasurements(80, 65, 30.4f); } }
(1)Subject
(2)observer.update(temperature,humidity,cleanness)
(3)notifyObservers()
(4)measurementsChanged()
(5)Observer
(6)envData.registerObserver(this)