Head First 设计模式 Design Pattern 附录 Mediator Memeto Prototype Visitor

最新推荐文章于 2026-04-20 00:56:48 发布
原创 最新推荐文章于 2026-04-20 00:56:48 发布 · 1.4k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

附录A: 余下的模式

6中介者 Mediator 集中相关对象之间复杂的沟通和控制方式

每个对象都会在自己的状态改变时告诉中介者; 每个对象都会对中介者发出的请求作出回应; 对象之间解耦;

>优点 对象的彼此解耦 增加对象的复用性; 将控制逻辑集中 简化系统维护; 让对象之间传递的信息变的简单轻量

>用途和缺点 用来协调相关的GUI组件; 如果设计不当 中介者对象本身会变得过于复杂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//***********Mediator***********                 
class Agent;                 
class Customer //Colleague                 
{                 
public:                 
    Customer() : miCounter(0) {};                 
    void purchase(Agent* m, int num);                 
    void updateCounter(int n);                 
private:                 
    int miCounter;                 
};                 
                                                                                                                                                       
class Producer //IColleague                 
{                 
public:                 
    Producer(int n)  : miInventory(n) {};                 
    void delivery(int n);                 
private:                 
    intmiInventory;                 
};                 
                                                                                                                                                               
classAgent //Mediator                 
{                 
public:                 
    void setCustomer(Customer* c) { mCustomer = c;}                 
    Customer* getColleagueA() { returnmCustomer;}                 
    void setProducer(Producer* B) { mProducer = B;}                 
    Producer* getProducer() { returnmProducer;}                 
    void purchase(int num);                 
private:                 
    Customer* mCustomer;                 
    Producer* mProducer;                 
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//***********Mediator***********                 
void Customer::purchase(Agent* m, int num)                 
{                 
    m->purchase(num);                 
}                 
                                                                                                                                                      
void Customer::updateCounter(int n)                 
{                 
    miCounter += n;                 
    cout<<"Customer: "<<miCounter<<endl;                 
}                 
                                                                                                                                                      
void Producer::delivery(int n)                 
{                 
    miInventory -= n;                 
    cout<<"Producer: "<<miInventory<<endl;                 
}                 
                                                                                                                                                      
void Agent::purchase(int num)                 
{                 
    mProducer->delivery(num);                 
    mCustomer->updateCounter(num);                 
}                 
        //Mediator                 
        Agent* agent =  newAgent();                 
        Customer* customer =  newCustomer();                 
        Producer* producer = newProducer(100);                 
        agent->setCustomer(customer);                 
        agent->setProducer(producer);                 
        customer->purchase(agent, 7);

7备忘录 Memeto 需要让对象返回之前的状态(请求'撤销')

>存储系统关键对象的重要状态; 维护关键对象的封装;

麦库截图20131818182353499.jpg

1)Memento 将Originator对象的内部状态存储起来; 2)Originator 创建一个含有当前内部状态的备忘录对象, 使用备忘录对象存储其内部状态; 3)Caretaker 负责保存备忘录对象, 不保存备忘录对象的内容

>优点 将状态放在外部, 防止和关键对象混淆, 帮助维护内聚; 保持关键对象的数据封装; 提供了容易实现的恢复能力;

>用途和缺点 用于存储状态; 缺点-存储和恢复状态的过程比较耗时; Java系统中可以使用序列化Serialization机制存储系统的状态.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//***********Memento***********        
class StateMem        
{        
public:        
    StateMem() : level(1), health(100) {};        
    int level;        
    int health;        
};        
                                                                                 
class Memento        
{        
public:        
    void setState(const StateMem& state);        
    StateMem getState() { return mstate;}        
private:        
    StateMem mstate;        
};        
                                                                                 
class Originator        
{        
public:        
    Originator(const StateMem& state) { mstate = state;}        
    void setLevel(int lev) { mstate.level = lev;}        
    void setHealth(int h) { mstate.health = h;}        
    Memento* createMemento();        
    void restoreMemento(Memento* mem);        
    void StateOutput();        
private:        
    StateMem mstate;        
};        
                                                                                 
class Caretaker        
{        
public:        
    void saveMemento(Memento* mem) { mMemento = mem;}        
    Memento* retrieveMemento() { return mMemento;}        
private:        
    Memento* mMemento;        
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//***********Memento***********        
void Memento::setState(const StateMem& state)        
{        
    mstate = state;        
}        
                                                                                
Memento* Originator::createMemento()        
{        
    Memento* mem = new Memento();        
    mem->setState(mstate);        
    return mem;        
}        
                                                                                
void Originator::restoreMemento(Memento* mem)        
{        
    mstate = mem->getState();        
}        
                                                                                
void Originator::StateOutput()        
{        
    cout<<"------State------"<<endl;        
    cout<<"Health: "<<mstate.health<<endl;        
    cout<<"Level: "<<mstate.level<<endl;        
}        
        //Memento        
        StateMem state;        
        Originator* originator = new Originator(state);        
        Memento* memento = originator->createMemento();        
        Caretaker* caretaker = new Caretaker();        
        caretaker->saveMemento(memento);        
        originator->setLevel(3);        
        originator->setHealth(150);        
        originator->StateOutput();        
        originator->restoreMemento(caretaker->retrieveMemento());        
        originator->StateOutput();

8原型 Prototype(拷贝) 当创建给定类的实例的过程很复杂很昂贵时使用

麦库截图20130521055426097.jpg

>Prototype 抽象原型角色, 抽象原型的定义, 包含一个Clone接口; ConcretePrototype 具体原型角色, 被原型复制的具体对象; Client 客户调用端.

>优点 对客户隐藏制造新实例的复杂性; 提供让客户能产生未知类型对象的选项; 某些情况复制对象比创建新对象更有效;

>用途和缺点 在复杂的类层次中, 当系统必须从其中的许多类型创建新对象时考虑原型; 实例化的类是在运行时刻决定的; 缺点-对象的复制有时很复杂;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//***********Prototype************        
class Prototype     
{     
public:     
    typedef enum
    {     
        NotDefined = 0,     
        Human = 1,     
        Alien= 2,     
    } Category;     
                                               
    Prototype() {};     
    virtual ~Prototype() {};     
    virtual Prototype* clone() = 0;     
};     
                                           
class Human : public Prototype     
{     
public:       
    typedef enum
    {     
        NotDefined = 0,     
        Male = 1,     
        Female = 2,     
    } Gender;     
    Human(const char* name, int height);     
    Human(const Human& h);     
    virtual ~Human();     
    void setGender(Gender g) { mGender = g;}     
    virtual Human* clone();     
    void Display();       
private:     
    char* mName;     
    int mHeight;     
    Gender mGender;     
    static int miObject;     
    static int ObjectNum();     
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//***********Prototype***********     
int Human::miObject = 0;     
Human::Human(const char* name, int height)     
{     
    if (name == NULL)     
    {     
        mName = new char[1];     
        mName = '\0';     
    }     
    else
    {     
        mName = new char[strlen(name) + 1];     
        strcpy(mName, name);     
    }     
    mHeight = height;     
    mGender = NotDefined;     
    miObject++;     
}     
                                          
Human::Human(const Human& h)     
{     
    mHeight = h.mHeight;     
    mGender = h.mGender;     
    mName = new char[strlen(h.mName) + 1];     
    strcpy(mName, h.mName);     
    miObject++;     
}     
                                          
Human::~Human()     
{     
    delete []mName;     
    miObject--;     
}     
                                          
Human* Human::clone()     
{     
    Human* human = new Human(*this); //copy construct     
    return human;     
}     
                                          
void Human::Display()     
{     
    cout<<"Object number: "<<ObjectNum()<<endl;     
    cout<<"Name-"<<mName<<"& Height-"<<mHeight<<endl;         
}     
                                          
int Human::ObjectNum()     
{     
    return miObject;     
}     
        //Prototype     
        Human* humanA = new Human("Peter", 180);     
        humanA->setGender(Human::Male);     
        Human* humanB = humanA->clone();     
        humanB->Display();     
        delete humanA;     
        humanB->Display();

9访问者 Visitor 为一个对象的组合增加新的能力, 并且封装不重要时

麦库截图20130822080715691.jpg

>优点 允许对组合结构加入新的操作, 无需修改结构本身; 相对易于加入新操作; 访问者进行的操作代码比较集中;

>用途和缺点 访问者模式打破组合类的封装; 由于游走的功能, 组合结构更加难以改变;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//***********Vistor************      
class IVistor;   
class IOperatingSystem   
{   
public:   
    virtual void accept(IVistor* v) = 0;   
    virtual void setName(string n) { mName = n;}   
    virtual string getName() const { return mName;}   
private:   
    string mName;   
};   
             
class Windows : public IOperatingSystem   
{   
public:   
    Windows(string name);      
    virtual void accept(IVistor* v);   
};   
             
class Linux : public IOperatingSystem   
{   
public:   
    Linux(string name, string version);   
    virtual void accept(IVistor* v);   
    string getVersion() const { return mVersion;}   
private:   
    string mVersion;   
};   
             
class IVistor   
{   
public:   
    virtual void visit(const Windows& win) = 0;   
    virtual void visit(const Linux& lin) = 0;   
};   
             
class Display : public IVistor   
{   
public:   
    virtual void visit(const Windows& win);   
    virtual void visit(const Linux& lin);   
};   
             
class Collection   
{   
public:   
    ~Collection();   
    void Add(IOperatingSystem* opSys);   
    void Print(IVistor* v);   
private:   
    typedef list<IOperatingSystem*> OperationSysList;   
    OperationSysList sysList;   
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
//***********Vistor***********  
Windows::Windows(string name)  
{  
    setName(name);  
}  
         
void Windows::accept(IVistor* v)  
{  
    v->visit(*this);  
}  
         
Linux::Linux(string name, string version) : mVersion(version)  
{  
    setName(name);  
}  
         
void Linux::accept(IVistor* v)  
{  
    v->visit(*this);  
}  
         
void Display::visit(const Windows& win)  
{  
    cout<<"---Windows---"<<endl;  
    cout<<"Name: "<<win.getName()<<endl;  
}  
         
void Display::visit(const Linux& lin)  
{  
    cout<<"---Linux---"<<endl;  
    cout<<"Name: "<<lin.getName()<<endl;  
    cout<<"Version: "<<lin.getVersion()<<endl;  
}  
         
Collection::~Collection()  
{  
    OperationSysList::const_iterator iter = sysList.begin();  
    for (; iter != sysList.end(); iter++)  
        delete *iter;  
}  
         
void Collection::Add(IOperatingSystem* opSys)  
{  
    sysList.push_back(opSys);  
}  
         
void Collection::Print(IVistor* v)  
{  
    OperationSysList::const_iterator iter = sysList.begin();  
    for (; iter != sysList.end(); iter++)  
    {  
        (*iter)->accept(v);  
    }  
}  
        //Vistor  
        Collection collection;  
        collection.Add(new Windows("Windows 7"));  
        Linux* lin = new Linux("Red Hat", "6.0");  
        collection.Add(lin);  
        collection.Print(new Display());

End

米家BLE广播协议（MI Beacon）Object字段解密
helpfu的博客
02-17 3042
米家BLE广播协议（MI Beacon）Object字段解密
java的object对象
悦分享
10-03 681
一、object对象 Object对象是除了基础对象之外，所有的对象都需要继承的父对象，包括数组也继承了Object。 二、object对象的方法 clone();调用该函数需要实现 Cloneable，否则会抛出  CloneNotSupportedException的异常。 equals();用来判断两个对象是否相等的函数，默认的是两个对象的地址比较，在使用Compare计算的时候，往...
Object的方法使用
mi_zhi_lu的博客
04-26 594
Object方法使用1. Object的方法1.1 public String toString() {} :获取对象信息1.2.public boolean equals(Object obj){} :对象比较2.接受所有引用型数据类型3.包装类Integer比较 1. Object的方法 Object：所有类的父类，可以接受所有类的对象 1.1 public String toString()...
使用MIME OBJECT
lyb_yt的专栏
05-11 700
<br /> <br /> 1.创建MIME object<br />    事物码SMW0创建二进制，选择自己的开发包，点击创建上传模板。<br />  2.在程序中下载模板<br /> *&---------------------------------------------------------------------*<br />*& INITIALIZATION<br />*&----------------------------------------------------------
认知几何学：思维的几何革命与跨学科价值研究（修订版）
shardylab.blog.csdn.net
04-20 424
在教学实践中，认知几何学支持具身认知的教学理念。在几何表示方面，认知流形的度规形式为：gμν(x) = exp[-d(x,x0)²/(2σ²)] × diag(-1, Φ, Φ⁻¹, Φ²)，其中x0是认知参考点（"自我"中心），σ是认知关联长度，Φ = (1+√5)/2是黄金比例。该规范势的几何不变量——认知曲率Ωc = dωc + ωc ∧ ωc——是本理论的核心动力学量，它定量刻画了认知系统的意识复杂度：曲率非零的区域对应意识体验高度整合且分化的"热点"，而平坦区域则对应自动化或无意识的信息处理。
Head First 设计模式 Design Pattern 7-8 Adapter & Facade, Template Method
Fix it
09-08 1666
Section 7 适配器模式和外观模式 Adapter & Facade >客户使用适配器 Client - Request -> Adapter -> TranslateRequest - Adaptee  客户通过目标接口调用适配器的方法发出请求; 适配器使用被适配者的接口把请求转换成被适配者的一个或多个调用接口; 客户收到调用结果, 并不知道是适配器在转化请求 >双向
Head First 设计模式 Design Pattern 1-2 Strategy, Observer
Fix it
07-21 1492
Section 1 策略模式 Strategy 模式:经验复用, 软件开发是在不断调整改变的 设计原则 找出应用中需要变化的部分, 把他们从不需要变化的代码中独立(封装)出来;  >分开变化和不变的部分, 代码变化引起的影响小, 系统有弹性 设计原则 针对接口编程, 不是针对实现编程 >利用接口表示行为, 针对超类型(Supertype)编程, 利用多态 设计原则
Head First 设计模式 Design Pattern 3-4 Decorator, Factory
Fix it
08-09 1255
Section 3 装饰者模式 Decorator  开放-关闭原则, 只在必须的地方使用开放-关闭原则, 否则增加复杂度, 代码阅读性变差 设计原则 类应该对扩展开放, 对修改关闭 >装饰者和被装饰者对象有相同的超类型 >可以用一个或者多个装饰者包装一个对象 >可以用被装饰过的对象代替原始对象 >装饰者可以在所委托被装饰者的行为之前/后加上自己的行为 >运行时
Head First 设计模式 Design Pattern 5-6 Singleton, Command
Fix it
08-16 1192
Section 5 单件模式 Singleton 创建独一无二的, 只能有一个实例的对象. 延迟实例化 Lazy Instantiaze 单件模式 确保一个类只有一个实例, 并提供一个全局访问点 处理多线程 >Java 利用同步, 缺点是降低性能;    >Java 利用急切 Eagerly方式创建单件, JVM保证在任何线程访问instance之前先
Head First 设计模式 Design Pattern 11-13 Proxy, Combining, For Real
Fix it
01-24 1106
Section 11 代理模式 Proxy 控制和管理访问  代理模式 为另一个对象提供一个替身或占位符以控制对这个对象的访问. 使用代理模式创建代表representative对象, 让代表对象控制某对象的访问, 被代理的对象可以是远程的对象, 创建开销大的对象或需要安全控制的对象. >远程代理Remote Proxy  隐藏远程细节, 调用代理的方法,
Head First 设计模式 Design Pattern 9-10 Iterator and Composite, State
Fix it
11-20 1098
Section 9 迭代器与组合模式 Iterator and Composite 对象超集合 super collection 聚合 aggregate >注意remove()在多线程中的状况   迭代器模式 提供一种方法顺序访问一个聚合对象中的各个元素, 不暴露其内部的表示. >内部迭代器, 外部迭代器, 迭代器的数据结构可以是有序的, 无序的, 重复的. 设计原则
Head First 设计模式 Design Pattern 附录 Bridge, Builder, Chain, Flyweight, Interpreter
Fix it
01-24 950
附录A: 余下的模式 1桥接 Bridge 不只改变实现, 也改变抽象 >优点 将实现解耦 让其和UI之间不再绑定; 抽象和实现可以独立扩展互不影响; 对于"具体的抽象类"所做的改变不影响客户 >用途和缺点 适合需要跨越多个平台的图形和窗口系统上; 当需要用不同的方式改变接口和实现时; 增加了复杂度; 1 2 3 4 5
stm32单片机项目资料课程设计文档C语言程序代码原理图电路PCB实例AVRM16L转S52板DXP资料及其相关资料
最新发布
06-23
stm32单片机项目资料课程设计文档C语言程序代码原理图电路PCB实例AVR M16L转S52板DXP资料及其相关资料
基于Matlab的直流电机双闭环控制系统仿真研究（Simulink仿真实现）
06-23
内容概要：本文系统地介绍了基于Matlab/Simulink平台的直流电机双闭环控制系统仿真研究，聚焦于由电流环和转速环构成的双闭环控制结构，详细阐述了PI控制器的设计原理与参数整定方法。通过Simulink搭建完整的电机控制仿真模型，深入分析系统在启动过程、突加负载等典型工况下的动态响应特性，全面验证了双闭环控制策略在提升系统稳定性、响应快速性及抗干扰能力方面的优越性能，为电机控制系统的理论教学、课程实践与工程应用提供了可靠的仿真依据和技术支撑； 适合人群：自动化、电气工程及其相关专业的本科高年级学生、研究生，以及从事电机控制、电力电子与运动控制领域研究的科研人员和工程技术人员； 使用场景及目标：①应用于高校课程设计、毕业设计及科研项目中的电机控制仿真任务；②掌握双闭环PI控制系统的控制机理与Simulink建模与仿真技能；③提升对电机动态性能评估、控制器设计与参数优化的综合实践能力； 阅读建议：建议读者结合Matlab/Simulink软件动手搭建仿真模型，逐步调试PI控制器参数，观察并分析不同参数对系统性能的影响，从而深入理解控制策略的核心作用机制，并可在掌握基础后进一步拓展至先进控制算法如模糊控制、自适应控制和模型预测控制的研究与实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值