《headfirst设计模式》读书笔记14-剩下的模式

1. 桥接

桥接其实就是将两个层次进行解耦

1.1 TV.h

#include <iostream>
using std::cout;
using std::endl;
class TV{
public:
    virtual void on()=0;
    virtual void off()=0;
    virtual void tuneChannel(int channel)=0;
    virtual int getChannel()=0;
    virtual ~TV(){};
};

1.2 TVFactory.h

#include "LG.h"
#include "Sony.h"
#include <string>
using std::string;
class TVFactory{
public:
    TV *getTV(string type){
        if(type=="LG"){
            return new LG();
        }else if(type=="Sony"){
            return new Sony();
        }else{
            std::cerr<<"Type mismatch";
            return nullptr;
        }
    }
};

1.3 RemoteControl.h

#include "TV.h"
#include "TVFactory.h"
class RemoteControl{
public:
    RemoteControl(TVFactory *tvFactory);
    virtual void on();
    virtual void off();
    virtual void setChannel(int channel);
    virtual int getChannel();
    virtual void setTV(string type);
    virtual ~RemoteControl();
private:
    TV *tv;
    TVFactory *tvFactory;
};

1.4 RemoteControl.cpp

#include "RemoteControl.h"

RemoteControl::RemoteControl(TVFactory *tvFactory)
{
    this->tvFactory=tvFactory;
}

void RemoteControl::on()
{
    tv->on();
}

void RemoteControl::off()
{
    tv->off();
}

void RemoteControl::setChannel(int channel)
{
    tv->tuneChannel(channel);
}

int RemoteControl::getChannel()
{
    return tv->getChannel();
}

void RemoteControl::setTV(std::string type)
{
    tv=tvFactory->getTV(type);
}

RemoteControl::~RemoteControl()
{

}

1.5 LG.h

#include "TV.h"
class LG:public TV{
    virtual void on()override final;
    virtual void off()override final;
    virtual void tuneChannel(int channel)override final;
    virtual int getChannel()override final;
    virtual ~LG();
private:
    int channel=1;
};

1.6 LG.cpp

#include "LG.h"

void LG::on()
{
    cout<<"Turning on the LG TV"<<endl;
}

void LG::off()
{
    cout<<"Turning off the LG TV"<<endl;
}

void LG::tuneChannel(int channel)
{
    this->channel=channel;
    cout<<"Set the LG TV Channel to " + std::to_string(this->channel)<<endl;
}

int LG::getChannel()
{
    return channel;
}

LG::~LG()
{

}

1.7 GenericRemote.h

#include "RemoteControl.h"
class GenericRemote:public RemoteControl{
public:
    GenericRemote(TVFactory *tvFactory);
    void nextChannel();
    void prevChannel();
    virtual ~GenericRemote();
};

1.8 GenericRemote.cpp

#include "GenericRemote.h"

GenericRemote::GenericRemote(TVFactory *tvFactory):RemoteControl(tvFactory)
{

}

void GenericRemote::nextChannel()
{
    int channel=getChannel();
    setChannel(channel+1);
}

void GenericRemote::prevChannel()
{
    int channel=getChannel();
    setChannel(channel-1);
}

GenericRemote::~GenericRemote()
{

}

2. 生成器

生成器模式其实就相当于根据你的需求创建一个数据结构，并且此结构运用了很多组合聚合，最后客户只需要给最后呈现的类进行打交道就行了

2.1 类图和部分源码

2.1.1 VacationBuilder.h

#include "Accommodation.h"
#include "Vacation.h"
#include <vector>
using std::vector;
class VacationBuilder{
public:
    virtual VacationBuilder *addAccommodation()=0;
    virtual VacationBuilder *addAccommodation(string name)=0;
    virtual VacationBuilder *addAccommodation(string name,
                                              int year,
                                              int month,
                                              int day,
                                              int nights,
                                              int location)=0;
    virtual VacationBuilder *addEvent(string event)=0;
    Vacation *getVacation(){
        Vacation *vacation=new Vacation();
        vacation->setName(name);
        vacation->setAccommodations(accommodations);
        vacation->setEvents(events);
        return vacation;
    }
    virtual ~VacationBuilder(){};

    string name;
    vector<Accommodation *> accommodations;
    vector<string> events;
};

2.1.2 Accommodation.h

#include "Reservation.h"
#include <string>
using std::string;
class Accommodation{
public:
    void setReservation(Reservation *r);
    Reservation *getReservation();
    virtual string getLocation()=0;
    string toString();
    virtual ~Accommodation();
    string name;
    Reservation *reservation=nullptr;
};

2.1.3 main.cpp

#include <iostream>
#include "VacationBuilder.h"
#include "CityVacationBuilder.h"
#include "OutdoorsVacationBuilder.h"
using namespace std;

int main()
{
    VacationBuilder *outdoorsyVacationBuilder = new OutdoorsVacationBuilder();
    Vacation *outdoorsyVacation = outdoorsyVacationBuilder
            ->addAccommodation("Two person tent", 2020, 7, 1, 5, 34)
            ->addEvent("Beach")
            ->addAccommodation("Two person tent")
            ->addEvent("Mountains")
            ->getVacation();
    cout<<outdoorsyVacation->toString()<<endl;

    VacationBuilder *cityVacationBuilder = new CityVacationBuilder();
    Vacation *cityVacation = cityVacationBuilder
            ->addAccommodation("Grand Facadian", 2020, 8, 1, 5, 0)
            ->addAccommodation("Hotel Commander", 2020, 8, 6, 2, 0)
            ->addEvent("Cirque du Soleil")
            ->getVacation();
    cout<<cityVacation->toString()<<endl;
    return 0;
}

3. 责任链

责任链模式其实就是超类的自关联，每个子类都是一道处理工序，子类继承后通过相应的工序连接相应的子类即可打造出一条链条

4. 蝇量

蝇量模式其实就是将一个实例放到不同位置，造成有许多个实例的假象

5. 解释器

解释器模式就相当于一种递归的用法，将表达式进行递归的分解，直到分解到可以执行的程度（相当于计算器的原理）

6. 中介者

中介者其实相当于将组件间复杂的沟通使用中介者进行集中沟通，其实有点像外观模式，但是这个应该更加复杂一点

7. 备忘录

8. 原型

9. 访问者