组合外观迭代器模式案例实验报告.docx

组合外观迭代器模式案例实验报告.docx

《组合外观迭代器模式案例实验报告.docx》由会员分享，可在线阅读，更多相关《组合外观迭代器模式案例实验报告.docx（16页珍藏版）》请在冰豆网上搜索。

组合外观迭代器模式案例实验报告

软件设计与体系结构

实验报告

课程名称

软件设计与体系结构

课程编号

0920116

实验项目名称

组合，外观，迭代器模式案例

学号

班级

姓名

专业

学生所在学院

指导教师

实验室名称地点

实验时间

实验名称：

迭代器，外观，组合模式案例

实验目的：

迭代器，外观，组合模式（ObserverPattern）是设计模式中行为模式的一种，它解决了上述具有一对多依赖关系的对象的重用问题。

此模式的参与者分为两大类，一类是被观察的目标，另一类是观察该目标的观察者们。

正因为该模式是基于“一对多”的关系，所以该模式一般是应用于由一个目标对象和N个观察者对象组成（当然也可以扩展为有多个目标对象，但我们现在只讨论前者）的场合。

当目标对象的状态发生改变或做出某种行为时，正在观察该目标对象的观察者们将自动地、连锁地作出相应的响应行为。

通过本次实验了解观察者模式的原理。

并能够运用观察者模式来进行编程。

实验内容

1UML类图

迭代器模式：

组合模式：

外观模式——冲茶

2程序的源代码

迭代器：

packageIterator;

importjava.util.Enumeration;

publicclassMyEnumeration{

privateEnumerationme;

privateintstep;

publicEnumerationgetMe（）{

returnme;

}

publicvoidsetMe（Enumerationme）{

this.me=me;

}

publicintgetStep（）{

returnstep;

}

publicvoidsetStep（intstep）{

this.step=step;

}

publicMyEnumeration（Enumeratione）{

me=e;

}

publicvoidtraverse（）{

while（me.hasMoreElements（））{

System.out.println（me.nextElement（））;

}

}

publicvoidjumptraverse（）{

while（me.hasMoreElements（））{

System.out.println（me.nextElement（））;

for（inti=1;i

if（me.hasMoreElements（））

me.nextElement（）;

}

}

}

}

packageIterator;

importjava.util.Enumeration;

importjava.util.Vector;

publicclassTest{

publicstaticvoidmain（String[]args）{

//TODOAuto-generatedmethodstub

Vectorv=newVector<>（）;

v.add（3）;

v.add（6）;

v.add（9）;

v.add（12）;

v.add（15）;

v.add（18）;

v.add（21）;

v.add（24）;

v.add（27）;

Enumeratione=v.elements（）;

MyEnumerationm=newMyEnumeration（e）;

System.out.println（"normaltraverse:

"）;

//m.traverse（）;

m.setStep（3）;

System.out.println（"jumptraverse:

"）;

m.jumptraverse（）;

}

}

组合模式：

packageCombination;

publicabstractclassCompany{

protectedStringname;

publicCompany（Strings）

{

name=s;

}

publicabstractvoidadd（Companyc）;

publicabstractvoidremove（Companyc）;

publicabstractvoiddisplay（intdepth）;

publicabstractvoidlineOfDuty（）;

}

packageCombination;

publicclassFinanceDepartmentextendsCompany{

publicFinanceDepartment（Strings）{

super（s）;

//TODOAuto-generatedconstructorstub

}

@Override

publicvoidadd（Companyc）{

//TODOAuto-generatedmethodstub

}

@Override

publicvoidremove（Companyc）{

//TODOAuto-generatedmethodstub

}

@Override

publicvoiddisplay（intdepth）{

//TODOAuto-generatedmethodstub

Strings="";

for（inti=0;i

{

s=s+'-';

}

System.out.println（s+name）;

}

@Override

publicvoidlineOfDuty（）{

//TODOAuto-generatedmethodstub

System.out.println（name+"负责管理公司财务收支"）;

}

}

packageCombination;

importjava.io.Serializable;

importjava.util.ArrayList;

importjava.util.Collection;

importjava.util.Iterator;

importjava.util.List;

importjava.util.ListIterator;

publicclassConcreteCompanyextendsCompanyimplementsSerializable{

privateListchildren;

publicConcreteCompany（Strings）{

super（s）;

children=newArrayList（）;

}

publicvoidadd（Companyc）{

//TOOAuto-generatedmethodstub

try{

children.add（c）;

}

catch（Exceptione）

{

if（children==null）

System.out.println（"cccc==null"）;

}

}

publicvoidremove（Companyc）{

//TODOAuto-generatedmethodstub

children.remove（c）;

}

publicvoiddisplay（intdepth）{

//TODOAuto-generatedmethodstub

Strings="";

for（inti=0;i

{

s=s+'-';

}

System.out.println（s+name）;

ListIteratori=children.listIterator（）;

while（i.hasNext（））

{

i.next（）.display（depth+2）;

}

}

publicvoidlineOfDuty（）{

//TODOAuto-generatedmethodstub

Iteratori=children.iterator（）;

while（i.hasNext（））

{

i.next（）.lineOfDuty（）;

}

}

}

packageCombination;

publicclassHRdepartmentextendsCompany{

publicHRdepartment（Strings）{

super（s）;

//TODOAuto-generatedconstructorstub

}

@Override

publicvoidadd（Companyc）{

//TODOAuto-generatedmethodstub

}

@Override

publicvoidremove（Companyc）{

//TODOAuto-generatedmethodstub

}

@Override

publicvoiddisplay（intdepth）{

//TODOAuto-generatedmethodstub

Strings="";

for（inti=0;i

{

s=s+'-';

}

System.out.println（s+name）;

}

@Override

publicvoidlineOfDuty（）{

//TODOAuto-generatedmethodstub

System.out.println（name+"负责员工招聘培训管理"）;

}

}

packageCombination;

publicclassTest{

publicstaticvoidmain（String[]args）{

ConcreteCompanyroot=newConcreteCompany（"北京总公司"）;

root.add（newHRdepartment（"总公司人力资源部"））;

root.add（newFinanceDepartment（"总公司财务部"））;

ConcreteCompanycomp=newConcreteCompany（"上海华东分公司"）;

comp.add（newHRdepartment（"华东分公司人力资源部"））;

comp.add（newFinanceDepartment（"华东分公司财务部"））;

root.add（comp）;

ConcreteCompanycomp1=newConcreteCompany（"南京办事处"）;

comp1.add（newHRdepartment（"南京办事处人力资源部"））;

comp1.add（newFinanceDepartment（"南京办事处财务部"））;

comp.add（comp1）;

ConcreteCompanycomp2=newConcreteCompany（"杭州办事处"）;

comp2.add（newHRdepartment（"杭州办事处人力资源部"））;

comp2.add（newFinanceDepartment（"杭州办事处财务部"））;

comp.add（comp2）;

System.out.println（"公司结构图"）;

root.display

（1）;

System.out.println（"各部门职责"）;

root.lineOfDuty（）;

}

}

外观模式——冲茶：

publicclassTeaBag{

publicTeaBag（）{

System.out.println（"清香的茶包准备好了"）;

}

}

publicclassWater{

booleanwaterIsBoiling;

publicWater（）{

setWaterIsBoiling（false）;

System.out.println（"纯净的水准备好了"）;

}

publicvoidboilFacadeWater（）{

setWaterIsBoiling（true）;

System.out.println（"水在沸腾"）;

}

publicvoidsetWaterIsBoiling（booleanisWaterBoiling）{

waterIsBoiling=isWaterBoiling;

}

publicbooleangetWaterIsBoiling（）{

returnwaterIsBoiling;

}

}

publicclassTeaCup{

booleanteaBagIsSteeped;

WaterfacadeWater;

TeaBagfacadeTeaBag;

publicTeaCup（）{

setTeaBagIsSteeped（false）;

System.out.println（"茶杯准备好了"）;

}

publicvoidsetTeaBagIsSteeped（booleanisTeaBagSteeped）{

teaBagIsSteeped=isTeaBagSteeped;

}

publicbooleangetTeaBagIsSteeped（）{

returnteaBagIsSteeped;

}

publicvoidaddFacadeTeaBag（TeaBagfacadeTeaBagIn）{

facadeTeaBag=facadeTeaBagIn;

System.out.println（"茶包放在苶杯了"）;

}

publicvoidaddFacadeWater（WaterfacadeWaterIn）{

facadeWater=facadeWaterIn;

System.out.println（"水倒入杯子了"）;

}

publicvoidsteepTeaBag（）{

if（（facadeTeaBag!

=null）&&

（（facadeWater!

=null）&&（facadeWater.getWaterIsBoiling（））））{

System.out.println（"茶渗透到杯子中"）;

setTeaBagIsSteeped（true）;

}

else{

System.out.println（"茶没有渗透到杯子中"）;

setTeaBagIsSteeped（false）;

}

}

publicStringtoString（）

{

if（this.getTeaBagIsSteeped（））{return（"一杯又香又浓的茶冲好了!

"）;}

else{

StringtempString=newString（"一个杯子"）;

if（facadeWater!

=null）{

if（facadeWater.getWaterIsBoiling（））{

tempString=（tempString+"放有沸腾的水"）;

}

else{

tempString=（tempString+"放有冻水"）;

}

}

else{

tempString=（tempString+"没有放水"）;

}

if（facadeTeaBag!

=null）{

tempString=（tempString+"有一个茶包"）;

}

else{

tempString=（tempString+"没有茶包"）;

}

returntempString;

}

}

}

publicclassFacadeCuppaMaker{

booleanteaBagIsSteeped;

publicFacadeCuppaMaker（）{System.out.println（"FacadeCuppaMaker准备可以为你冲茶了!

"）;

}

publicTeaCupmakeACuppa（）{

TeaCupcup=newTeaCup（）;

TeaBagteaBag=newTeaBag（）;

Waterwater=newWater（）;

cup.addFacadeTeaBag（teaBag）;

water.boilFacadeWater（）;

cup.addFacadeWater（water）;

cup.steepTeaBag（）;

returncup;

}

}

publicclassClient{

publicstaticvoidmain（String[]args）{

FacadeCuppaMakercuppaMaker=newFacadeCuppaMaker（）;

TeaCupteaCup=cuppaMaker.makeACuppa（）;

System.out.println（teaCup）;

}

}

3实验截图

迭代器：

组合模式：

外观模式——冲茶：

对该模式的认识

经过本次的实验，通过自己动手编代码，是自己理解了模式机制，并且知道迭代器模式有适用性迭代器模式可用来：

支持无需暴露聚合对象内部表示的聚合对象遍历支持聚合对象的多个遍历同时进行为遍历不同的聚合结构提供一个统一的接口（即,支持多态迭代）。

优点简化聚合的接口，使其不被遍历方法污染

支持多个遍历同时进行，支持不同的遍历技术。

缺点无。

组合模式适用性你想表示对象的部分-整体层次结构；你想要用户能够忽略对象组合与单个对象的差异，用户将一致地处理组合结构中的所有对象。

优点

使得更容易增加新类型的组件，使得客户代码更简单，因为客户不必知道他们正在处理的是叶组件还是组合组件。

缺点：

使得更难以限制组合中的组件类型。

外观模式：

适用性以下情况使用外观模式：

为一个复杂子系统提供一个简单接口时。

该接口对大多数客户而言都足够好；更高级的客户能够穿越外观对象。

将子系统的类与客户和其他子系统分离，从而提高子系统的独立性和可移植性，收益它对客户隐藏子系统的实现，从而使子系统更易于使用它有利于子系统与客户之间的弱耦合。

这就允许改变所包含的子系统但不影响客户。

在大型软件系统中降低编译依赖性简化将系统移植到其他平台的过程，因为编译一个子系统一般不需要编译所有其他的子系统。

不阻止高级客户访问低层类注意：

外观不增加任何功能，它只是简化接口，缺陷不阻止高级客户访问低层类！

经过本次实验课的练习，我明白了编代码也是一种技巧，而设计模式便是大家提炼出来的有技巧编代码。

使我对软件设计与体系结构这门课有了浓厚的兴趣，相信在学习这门课的知识，会让我获益良多。

扣分原因（有扣分时填写）

扣分