《设计模式》实验指导书.docx
《《设计模式》实验指导书.docx》由会员分享，可在线阅读，更多相关《《设计模式》实验指导书.docx（29页珍藏版）》请在冰点文库上搜索。
《设计模式》实验指导书
哈尔滨理工大学计算机学院
实验教学中心
《设计模式》实验
实验指导书3
实验一Factory模式与AbstractFactory模式3
实验二Adapter模式9
实验三Observer模式12
实验四Interpreter模式16
实验指导书
实验一Factory模式与AbstractFactory模式
[实验目的]
1．掌握Factory模式与AbstractFactory模式的意图及其代码实现。
2．了解两种模式的区别。
[实验内容]
用C++语言实现Factory模式与AbstractFactory模式。
[实验要点及说明]
1、Factory模式
Factory模式的作用：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。
FactoryMethod使一个类的实例化延迟到其子类。
UML结构图：
抽象基类：
1）Product：
创建出来的对象的抽象基类。
2）Factory：
创建对象的工厂方法的抽象基类。
接口函数：
1）Creator:
:
FactoryMethod:
纯虚函数,由派生类实现，创建出对应的Product。
解析：
在这个模式中,有两个抽象基类，一个是Product为创建出来的对象的抽象基类，一个是Factory是工厂的抽象基类，在互相协作的时候都是由相应的Factory派生类来生成Product的派生类，也就是说如果要新增一种Product那么也要对应的新增一个Factory，创建的过程委托给了这个Factory，也就是说一个Factory和一个Product是一一对应的关系。
备注：
设计模式的演示图上把Factory类命名为Creator，下面的实现沿用了这个命名。
演示实现：
1）Factory.h
#ifndefFACTORY_H
#defineFACTORY_H
classProduct
{
public:
Product（）{}
virtual~Product（）{}
};
classConcreateProduct
:
publicProduct
{
public:
ConcreateProduct（）;
virtual~ConcreateProduct（）;
};
classCreator
{
public:
Creator（）{}
virtual~Creator（）{}
voidAnOperation（）;
protected:
virtualProduct*FactoryMethod（）=0;
};
classConcreateCreator
:
publicCreator
{
public:
ConcreateCreator（）;
virtual~ConcreateCreator（）;
protected:
virtualProduct*FactoryMethod（）;
};
#endif
2）Factory.cpp
#include"Factory.h"
#include
usingnamespacestd;
ConcreateProduct:
:
ConcreateProduct（）
{
std:
:
cout<<"constructionofConcreateProduct\n";
}
ConcreateProduct:
:
~ConcreateProduct（）
{
std:
:
cout<<"destructionofConcreateProduct\n";
}
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（）;
}
3）Main.cpp（测试代码）
#include"Factory.h"
#include
intmain（intargc,char*argv[]）
{
Creator*p=newConcreateCreator（）;
p->AnOperation（）;
deletep;
system（"pause"）;
return0;
}
2、AbstractFactory模式
作用：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
UML结构图：
抽象基类：
1）ProductA，ProductB：
分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现。
2）AbstractFactory：
生产这一系列产品的一个抽象工厂，它的派生类是不同的实现。
接口函数：
AbstractFactory:
:
CreateProductA和AbstractFactory:
:
CreateProductB：
分别是生产不同产品的不同的实现，由各个派生出来的抽象工厂实现之。
解析：
AbstractFactory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂等等。
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现。
显而易见的，如果有n种产品同时有m中不同的实现，那么根据乘法原理可知有n*m个Factory模式的使用。
实现:
1）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
2）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（）;
}
3）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;
}
讨论
AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。
实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。
并且可以看到，AbstractFactory模式通常都是使用Factory模式实现。
实验二Adapter模式
[实验目的]
掌握Adapter模式的意图及其代码实现。
[实验内容]
用C++语言实现Adapter模式。
[实验要点及说明]
Adapter模式的作用：
将一个类的接口转换成客户希望的另外一个接口。
Adapt模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
UML示意图
1）采用继承原有接口类的方式
2）采用组合原有接口类的方式
解析：
Adapt模式其实就是把完成同样的一个功能但是接口不能兼容的类桥接在一起使之可以在一起工作，这个模式使得复用旧的接口成为可能。
实现：
Adapt模式有两种实现办法，一种是采用继承原有接口类的方法，一种是采用组合原有接口类的方法，这里采用的是第二种实现方法。
1）Adapt.h
#ifndefADAPTER_H
#defineADAPTER_H
//需要被Adapt的类
classTarget
{
public:
Target（）{}
virtual~Target（）{}
virtualvoidRequest（）=0;
};
//与被Adapt对象提供不兼容接口的类
classAdaptee
{
public:
Adaptee（）{}
~Adaptee（）{}
voidSpecialRequest（）;
};
//进行Adapt的类,采用聚合原有接口类的方式
classAdapter
:
publicTarget
{
public:
Adapter（Adaptee*pAdaptee）;
virtual~Adapter（）;
virtualvoidRequest（）;
private:
Adaptee*m_pAdptee;
};
#endif
2）Adapt.cpp
#include"Adapter.h"
#include
voidAdaptee:
:
SpecialRequest（）
{
std:
:
cout<<"SpecialRequestofAdaptee\n";
}
Adapter:
:
Adapter（Adaptee*pAdaptee）
:
m_pAdptee（pAdaptee）
{
}
Adapter:
:
~Adapter（）
{
deletem_pAdptee;
m_pAdptee=NULL;
}
voidAdapter:
:
Request（）
{
std:
:
cout<<"RequestofAdapter\n";
m_pAdptee->SpecialRequest（）;
}
3）Main.cpp
#include"Adapter.h"
#include
intmain（）
{
Adaptee*pAdaptee=newAdaptee;
Target*pTarget=newAdapter（pAdaptee）;
pTarget->Request（）;
deletepTarget;
system（"pause"）;
return0;
}
实验三Observer模式
[实验目的]
掌握Observer模式的意图及其代码实现。
[实验内容]
用C++语言实现Observer模式。
[实验要点及说明]
Observer模式的作用：
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
UML结构图：
解析：
Observer模式定义的是一种一对多的关系，这里的一就是图中的Subject类，而多则是Observer类。
当Subject类的状态发生变化的时候通知与之对应的Observer类也去相应的更新状态，同时支持动态的添加和删除Observer对象的功能。
Observer模式的实现要点是：
第一，一般subject类都是采用链表等容器来存放Observer对象；第二抽取出Observer对象的一些公共的属性形成Observer基类，而Subject中保存的则是Observer类对象的指针，这样就使Subject和具体的Observer实现了解耦，也就是Subject不需要去关心到底是哪个Observer对放进了自己的容器中。
生活中有很多例子可以看作是Observer模式的运用，比方说，一个班有一个班主任（Subject），他管理手下的一帮学生（Observer），当班里有一些事情发生需要通知学生的时候，班主任要做的不是逐个学生挨个的通知，而是把学生召集起来一起通知，实现了班主任和具体学生的关系解耦。
实现：
1）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~Conc
升级会员 