10软工设计模式Word文档格式.docx
- 文档编号:19991551
- 上传时间:2023-01-13
- 格式:DOCX
- 页数:22
- 大小:109.04KB
10软工设计模式Word文档格式.docx
《10软工设计模式Word文档格式.docx》由会员分享,可在线阅读,更多相关《10软工设计模式Word文档格式.docx(22页珍藏版)》请在冰豆网上搜索。
4、
5、
6、
小组成员
姓名
学号
组内分工
自我评分
教师评分
赵晓宇
09065084
实验一实验三
5
崔伟峰
090651095
实验二实验三
小
组
成
绩
评
定
教师签名:
年月日
实验分项1
实验一创建型模式(Factory模式与AbstractFactory模式)
目
的
1、掌握Factory模式与AbstractFactory模式的意图及其代码实现。
2、了解两种模式的区别。
要
求
具体题目
用C++或Java语言实现Factory模式与AbstractFactory模式。
系统平台
VC6.0或以上版本环境下均可
原
理
及
步
骤
Factory.h
#ifndefFACTORY_H
#defineFACTORY_H
//Product
classProduct
{
public:
Product(){}
virtual~Product(){}
};
//继承自Product的ConcreateProduct子类
classConcreateProduct:
publicProduct
ConcreateProduct();
virtual~ConcreateProduct();
//Creator
classCreator
Creator(){}
virtual~Creator(){}
voidAnOperation();
protected:
virtualProduct*FactoryMethod()=0;
//继承自Creator的ConcreateCreator子类
classConcreateCreator:
publicCreator
public:
ConcreateCreator();
virtual~ConcreateCreator();
virtualProduct*FactoryMethod();
#endif
*******************************************
Factory.cpp
#include"
Factory.h"
#include<
iostream>
usingnamespacestd;
ConcreateProduct:
:
ConcreateProduct()
std:
cout<
<
"
constructionofConcreateProduct\n"
;
}//创建ConcteateProduct
~ConcreateProduct()
destructionofConcreateProduct\n"
}//销毁ConcteateProduct
voidCreator:
AnOperation()
Product*p=FactoryMethod();
anoperationofproduct\n"
}
ConcreateCreator:
ConcreateCreator()
constructionofConcreateCreator\n"
~ConcreateCreator()
destructionofConcreateCreator\n"
Product*ConcreateCreator:
FactoryMethod()
returnnewConcreateProduct();
*************************************
Main.cpp
stdlib.h>
intmain(intargc,char*argv[])
Creator*p=newConcreateCreator();
p->
AnOperation();
deletep;
system("
pause"
);
return0;
结
果
析
心
得
体
会
软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。
真正领悟设计模式的精髓是可能一个漫长的过程,需要大量实践经验的积累。
Factory模式的作用:
定义一个用于创建对象的接口,让子类决定实例化哪一个类。
FactoryMethod使一个类的实例化延迟到其子类AbstractFactory模式作用:
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
实验分项2
实验二结构型模式(Adapter模式)
一、掌握Adapter模式的意图及其代码实现
用C++或Java语言实现Adapter模式
VC6.0以及以上版本均可以
AbstractFactory.h
#ifndefABSTRACTFACTORY_H
#defineABSTRACTFACTORY_H
//抽象基类AbstractProductA,代表产品A的抽象
classAbstractProductA
AbstractProductA(){}
virtual~AbstractProductA(){};
//派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
classConcreateProductA1
publicAbstractProductA
ConcreateProductA1();
virtual~ConcreateProductA1();
//派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
classConcreateProductA2
ConcreateProductA2();
virtual~ConcreateProductA2();
//抽象基类AbstractProductB,代表产品B的抽象
classAbstractProductB
AbstractProductB(){}
virtual~AbstractProductB(){};
//派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
classConcreateProductB1
publicAbstractProductB
ConcreateProductB1();
virtual~ConcreateProductB1();
//派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
classConcreateProductB2
ConcreateProductB2();
virtual~ConcreateProductB2();
//抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
classAbstractFactory
AbstractFactory(){}
virtual~AbstractFactory(){}
virtualAbstractProductA*CreateProductA()=0;
virtualAbstractProductB*CreateProductB()=0;
//派生类ConcreateFactory1,继承自AbstractFactory
//生产产品A和产品B的第一种实现
classConcreateFactory1
publicAbstractFactory
ConcreateFactory1();
virtual~ConcreateFactory1();
virtualAbstractProductA*CreateProductA();
virtualAbstractProductB*CreateProductB();
//派生类ConcreateFactory2,继承自AbstractFactory
//生产产品A和产品B的第二种实现
classConcreateFactory2
ConcreateFactory2();
virtual~ConcreateFactory2();
************************************************
AbstractFactory.cpp
AbstractFactory.h"
ConcreateProductA1:
ConcreateProductA1()
constructionofConcreateProductA1\n"
~ConcreateProductA1()
destructionofConcreateProductA1\n"
ConcreateProductA2:
ConcreateProductA2()
constructionofConcreateProductA2\n"
~ConcreateProductA2()
destructionofConcreateProductA2\n"
ConcreateProductB1:
ConcreateProductB1()
constructionofConcreateProductB1\n"
~ConcreateProductB1()
destructionofConcreateProductB1\n"
ConcreateProductB2:
ConcreateProductB2()
constructionofConcreateProductB2\n"
~ConcreateProductB2()
destructionofConcreateProductB2\n"
ConcreateFactory1:
ConcreateFactory1()
constructionofConcreateFactory1\n"
~ConcreateFactory1()
destructionofConcreateFactory1\n"
AbstractProductA*ConcreateFactory1:
CreateProductA()
returnnewConcreateProductA1();
AbstractProductB*ConcreateFactory1:
CreateProductB()
returnnewConcreateProductB1();
ConcreateFactory2:
ConcreateFactory2()
constructionofConcreateFactory2\n"
~ConcreateFactory2()
destructionofConcreateFactory2\n"
AbstractProductA*ConcreateFactory2:
returnnewConcreateProductA2();
AbstractProductB*ConcreateFactory2:
returnnewConcreateProductB2();
***************************************************
intmain()
//生产产品A的第一种实现
ConcreateFactory1*pFactory1=newConcreateFactory1;
AbstractProductA*pProductA=pFactory1->
CreateProductA();
//生产产品B的第二种实现
ConcreateFactory2*pFactory2=newConcreateFactory2;
AbstractProductB*pProductB=pFactory2->
CreateProductB();
deletepFactory1;
deletepProductA;
deletepFactory2;
deletepProductB;
Adapter模式的作用:
将一个类的接口转换成客户希望的另外一个接口。
Adapt模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
实验分项3
实验三行为型模式(Observer模式)
一、掌握Observer模式的意图及其代码实现。
用C++或Java语言实现Observer模式
Observer.h
#ifndefOBSERVER_H
#defineOBSERVER_H
list>
typedefintSTATE;
classObserver;
//Subject抽象基类,只需要知道Observer基类的声明就可以了
classSubject
Subject():
m_nSubjectState(-1){}
virtual~Subject();
voidNotify();
//通知对象改变状态
voidAttach(Observer*pObserver);
//新增对象
voidDetach(Observer*pObserver);
//删除对象
//虚函数,提供默认的实现,派生类可以自己实现来覆盖基类的实现
virtualvoidSetState(STATEnState);
//设置状态
virtualSTATEGetState();
//得到状态
STATEm_nSubjectState;
//模拟保存Subject状态的变量
list<
Observer*>
m_ListObserver;
//保存Observer指针的链表
//Observer抽象基类
classObserver
Observer():
m_nObserverState(-1){}
virtual~Observer(){}
//纯虚函数,各个派生类可能有不同的实现
//通知Observer状态发生了变化
virtualvoidUpdate(Subject*pSubject)=0;
STATEm_nObserverState;
//模拟保存Observer状态的变量
//ConcreateSubject类,派生在Subject类
classConcreateSubject
publicSubject
ConcreateSubject():
Subject(){}
virtual~ConcreateSubject(){}
//派生类自己实现来覆盖基类的实现
//ConcreateObserver类派生自Observer
classConcreateObserver
publicObserver
ConcreateObserver():
Observer(){}
virtual~ConcreateObserver(){}
//虚函数,实现基类提供的接口
virtualvoidUpdate(Subject*pSubject);
***************************************
Observer.cpp
Observer.h"
algorithm>
/*--------------------------------------------------------------------
|Subject类成员函数的实现
|
----------------------------------------------------------------------*/
voidSubject:
Attach(Observer*pObserver)
AttachanObserver\n"
m_ListObserver.push_back(pObserver);
Detach(Observer*pObserver)
iteratoriter;
iter=std:
find(m_ListObserver.begin(),m_ListObserver.end(),pObserver);
if(m_ListObserver.end()!
=iter)
m_ListObserver.erase(iter);
DetachanObserver\n"
Notify()
NotifyObservers'
sState\n"
iteratoriter1,iter2;
for(iter1=m_ListObserver.begin(),iter2=m_ListObserver.end();
iter1!
=iter2;
++iter1)
(*iter1)->
Update(this);
SetState(STATEnState)
SetStateBySubject\n"
m_nSubjectState=nState;
STATESubject:
GetState()
GetStateBySubject\n"
returnm_nSubjectState;
Subject:
~Subject()
iteratoriter1,iter2,temp;
)
temp=iter1;
++iter1;
delete(*temp);
m_ListObserver.clear();
|ConcreateSubject类成员函数的实现
voidConcreateSubject:
cout
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 10 设计 模式