10软工设计模式.docx
《10软工设计模式.docx》由会员分享，可在线阅读，更多相关《10软工设计模式.docx（22页珍藏版）》请在冰豆网上搜索。
10软工设计模式
院系：
计算机科学学院
专业：
软件工程
年级：
2010
课程名称：
设计模式
指导教师：
艾勇
组号：
学号：
0906508409065109
姓名：
赵晓宇崔伟峰
2013年10月25日
年级
2010
专业
软件工程
班级
01
实验
名称
设计模式程序设计
实
验
分
项
内
容
分项内容
1、实验一创建型模式（Factory模式与AbstractFactory模式）
2、实验二结构型模式（Adapter模式）
3、实验三行为型模式（Observer模式）
4、
5、
6、
小组成员
姓名
学号
组内分工
自我评分
教师评分
赵晓宇
09065084
实验一实验三
5
崔伟峰
090651095
实验二实验三
5
小
组
成
绩
评
定
教师签名：
年月日
实验分项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
{
public:
ConcreateProduct（）;
virtual~ConcreateProduct（）;
};
//Creator
classCreator
{
public:
Creator（）{}
virtual~Creator（）{}
voidAnOperation（）;
protected:
virtualProduct*FactoryMethod（）=0;
};
//继承自Creator的ConcreateCreator子类
classConcreateCreator:
publicCreator
{
public:
ConcreateCreator（）;
virtual~ConcreateCreator（）;
protected:
virtualProduct*FactoryMethod（）;
};
#endif
*******************************************
Factory.cpp
#include"Factory.h"
#include
usingnamespacestd;
ConcreateProduct:
:
ConcreateProduct（）
{
std:
:
cout<<"constructionofConcreateProduct\n";
}//创建ConcteateProduct
ConcreateProduct:
:
~ConcreateProduct（）
{
std:
:
cout<<"destructionofConcreateProduct\n";
}//销毁ConcteateProduct
voidCreator:
:
AnOperation（）
{
Product*p=FactoryMethod（）;
std:
:
cout<<"anoperationofproduct\n";
}
ConcreateCreator:
:
ConcreateCreator（）
{
std:
:
cout<<"constructionofConcreateCreator\n";
}
ConcreateCreator:
:
~ConcreateCreator（）
{
std:
:
cout<<"destructionofConcreateCreator\n";
}
Product*ConcreateCreator:
:
FactoryMethod（）
{
returnnewConcreateProduct（）;
}
*************************************
Main.cpp
#include"Factory.h"
#include
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
{
public:
AbstractProductA（）{}
virtual~AbstractProductA（）{};
};
//派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
classConcreateProductA1
:
publicAbstractProductA
{
public:
ConcreateProductA1（）;
virtual~ConcreateProductA1（）;
};
//派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
classConcreateProductA2
:
publicAbstractProductA
{
public:
ConcreateProductA2（）;
virtual~ConcreateProductA2（）;
};
//抽象基类AbstractProductB,代表产品B的抽象
classAbstractProductB
{
public:
AbstractProductB（）{}
virtual~AbstractProductB（）{};
};
//派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
classConcreateProductB1
:
publicAbstractProductB
{
public:
ConcreateProductB1（）;
virtual~ConcreateProductB1（）;
};
//派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
classConcreateProductB2
:
publicAbstractProductB
{
public:
ConcreateProductB2（）;
virtual~ConcreateProductB2（）;
};
//抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
classAbstractFactory
{
public:
AbstractFactory（）{}
virtual~AbstractFactory（）{}
virtualAbstractProductA*CreateProductA（）=0;
virtualAbstractProductB*CreateProductB（）=0;
};
//派生类ConcreateFactory1,继承自AbstractFactory
//生产产品A和产品B的第一种实现
classConcreateFactory1
:
publicAbstractFactory
{
public:
ConcreateFactory1（）;
virtual~ConcreateFactory1（）;
virtualAbstractProductA*CreateProductA（）;
virtualAbstractProductB*CreateProductB（）;
};
//派生类ConcreateFactory2,继承自AbstractFactory
//生产产品A和产品B的第二种实现
classConcreateFactory2
:
publicAbstractFactory
{
public:
ConcreateFactory2（）;
virtual~ConcreateFactory2（）;
virtualAbstractProductA*CreateProductA（）;
virtualAbstractProductB*CreateProductB（）;
};
#endif
************************************************
AbstractFactory.cpp
#include
#include"AbstractFactory.h"
ConcreateProductA1:
:
ConcreateProductA1（）
{
std:
:
cout<<"constructionofConcreateProductA1\n";
}
ConcreateProductA1:
:
~ConcreateProductA1（）
{
std:
:
cout<<"destructionofConcreateProductA1\n";
}
ConcreateProductA2:
:
ConcreateProductA2（）
{
std:
:
cout<<"constructionofConcreateProductA2\n";
}
ConcreateProductA2:
:
~ConcreateProductA2（）
{
std:
:
cout<<"destructionofConcreateProductA2\n";
}
ConcreateProductB1:
:
ConcreateProductB1（）
{
std:
:
cout<<"constructionofConcreateProductB1\n";
}
ConcreateProductB1:
:
~ConcreateProductB1（）
{
std:
:
cout<<"destructionofConcreateProductB1\n";
}
ConcreateProductB2:
:
ConcreateProductB2（）
{
std:
:
cout<<"constructionofConcreateProductB2\n";
}
ConcreateProductB2:
:
~ConcreateProductB2（）
{
std:
:
cout<<"destructionofConcreateProductB2\n";
}
ConcreateFactory1:
:
ConcreateFactory1（）
{
std:
:
cout<<"constructionofConcreateFactory1\n";
}
ConcreateFactory1:
:
~ConcreateFactory1（）
{
std:
:
cout<<"destructionofConcreateFactory1\n";
}
AbstractProductA*ConcreateFactory1:
:
CreateProductA（）
{
returnnewConcreateProductA1（）;
}
AbstractProductB*ConcreateFactory1:
:
CreateProductB（）
{
returnnewConcreateProductB1（）;
}
ConcreateFactory2:
:
ConcreateFactory2（）
{
std:
:
cout<<"constructionofConcreateFactory2\n";
}
ConcreateFactory2:
:
~ConcreateFactory2（）
{
std:
:
cout<<"destructionofConcreateFactory2\n";
}
AbstractProductA*ConcreateFactory2:
:
CreateProductA（）
{
returnnewConcreateProductA2（）;
}
AbstractProductB*ConcreateFactory2:
:
CreateProductB（）
{
returnnewConcreateProductB2（）;
}
***************************************************
Main.cpp
#include"AbstractFactory.h"
#include
intmain（）
{
//生产产品A的第一种实现
ConcreateFactory1*pFactory1=newConcreateFactory1;
AbstractProductA*pProductA=pFactory1->CreateProductA（）;
//生产产品B的第二种实现
ConcreateFactory2*pFactory2=newConcreateFactory2;
AbstractProductB*pProductB=pFactory2->CreateProductB（）;
deletepFactory1;
deletepProductA;
deletepFactory2;
deletepProductB;
system（"pause"）;
return0;
}
实
验
结
果
及
分
析
心
得
体
会
Adapter模式的作用：
将一个类的接口转换成客户希望的另外一个接口。
Adapt模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
实验分项3
实验三行为型模式（Observer模式）
实
验
目
的
一、掌握Observer模式的意图及其代码实现。
实
验
要
求
具体题目
用C++或Java语言实现Observer模式
系统平台
VC6.0以及以上版本均可以
实
验
原
理
及
步
骤
Observer.h
#ifndefOBSERVER_H
#defineOBSERVER_H
#include
typedefintSTATE;
classObserver;
//Subject抽象基类,只需要知道Observer基类的声明就可以了
classSubject
{
public:
Subject（）:
m_nSubjectState（-1）{}
virtual~Subject（）;
voidNotify（）;//通知对象改变状态
voidAttach（Observer*pObserver）;//新增对象
voidDetach（Observer*pObserver）;//删除对象
//虚函数,提供默认的实现,派生类可以自己实现来覆盖基类的实现
virtualvoidSetState（STATEnState）;//设置状态
virtualSTATEGetState（）;//得到状态
protected:
STATEm_nSubjectState;//模拟保存Subject状态的变量
std:
:
listm_ListObserver;//保存Observer指针的链表
};
//Observer抽象基类
classObserver
{
public:
Observer（）:
m_nObserverState（-1）{}
virtual~Observer（）{}
//纯虚函数,各个派生类可能有不同的实现
//通知Observer状态发生了变化
virtualvoidUpdate（Subject*pSubject）=0;
protected:
STATEm_nObserverState;//模拟保存Observer状态的变量
};
//ConcreateSubject类,派生在Subject类
classConcreateSubject
:
publicSubject
{
public:
ConcreateSubject（）:
Subject（）{}
virtual~ConcreateSubject（）{}
//派生类自己实现来覆盖基类的实现
virtualvoidSetState（STATEnState）;//设置状态
virtualSTATEGetState（）;//得到状态
};
//ConcreateObserver类派生自Observer
classConcreateObserver
:
publicObserver
{
public:
ConcreateObserver（）:
Observer（）{}
virtual~ConcreateObserver（）{}
//虚函数,实现基类提供的接口
virtualvoidUpdate（Subject*pSubject）;
};
#endif
***************************************
Observer.cpp
#include"Observer.h"
#include
#include
/*--------------------------------------------------------------------
|Subject类成员函数的实现
|
----------------------------------------------------------------------*/
voidSubject:
:
Attach（Observer*pObserver）
{
std:
:
cout<<"AttachanObserver\n";
m_ListObserver.push_back（pObserver）;
}
voidSubject:
:
Detach（Observer*pObserver）
{
std:
:
list:
:
iteratoriter;
iter=std:
:
find（m_ListObserver.begin（）,m_ListObserver.end（）,pObserver）;
if（m_ListObserver.end（）!
=iter）
{
m_ListObserver.erase（iter）;
}
std:
:
cout<<"DetachanObserver\n";
}
voidSubject:
:
Notify（）
{
std:
:
cout<<"NotifyObservers'sState\n";
std:
:
list:
:
iteratoriter1,iter2;
for（iter1=m_ListObserver.begin（）,iter2=m_ListObserver.end（）;
iter1!
=iter2;
++iter1）
{
（*iter1）->Update（this）;
}
}
voidSubject:
:
SetState（STATEnState）
{
std:
:
cout<<"SetStateBySubject\n";
m_nSubjectState=nState;
}
STATESubject:
:
GetState（）
{
std:
:
cout<<"GetStateBySubject\n";
returnm_nSubjectState;
}
Subject:
:
~Subject（）
{
std:
:
list:
:
iteratoriter1,iter2,temp;
for（iter1=m_ListObserver.begin（）,iter2=m_ListObserver.end（）;
iter1!
=iter2;
）
{
temp=iter1;
++iter1;
delete（*temp）;
}
m_ListObserver.clear（）;
}
/*--------------------------------------------------------------------
|ConcreateSubject类成员函数的实现
|
----------------------------------------------------------------------*/
voidConcreateSubject:
:
SetState（STATEnState）
{
std:
:
cout
升级会员 