建造者模式(Builder)
工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
建造者模式:将复杂对象的构建、表示分离,使得同样的构建过程可以创建不同的表示。
主要解决:一个复杂对象的创建工作,由各个部分的子对象用一定的算法构成;由于需求变化,这个复杂对象的各个部分经常面临变化,但将它们组合在一起的算法却相对稳定。
如何解决:将变与不变分开
关键代码:建造者:创建和提供实例,Director:管理建造出来的实例的依赖关系。。
缺点:1、产品必须有共同点,范围有限制。 2、如内部变化复杂,会有很多的建造类。
在抽象建造者上使用了模板方法模式,每一个建造者都必须返回一个产品,但是产品是如何制造的,则由各个建造者自己负责。
超人这个产品是由三部分组成:躯体、特殊技能、身份标记,这就类似于电子产品,首先生产出一个固件,然后再安装一个灵魂(软件驱动),最后再打上产品标签。一个崭新的产品就诞生。我们的超人也是这样生产的,先生产一个普通的躯体,然后注入特殊技能,最后打上S标签,一个超人生产完毕。
class CSuperMan
{
public:
CSuperMan(){};
~CSuperMan(){};
string msGetBody() { return msBody; };
void mvSetBody(const string &sBody) { msBody = sBody; };
string msGetSpecialTalent() { return msSpecialTalent; };
void mvSetSpecialTalent(const string &sSpecialTalent) { msSpecialTalent = sSpecialTalent; };
string msGetSpecialSymbol() { return msSpecialSymbol; };
void mvSetSpecialSymbol(const string &sSpecialSymbol) { msSpecialSymbol = sSpecialSymbol; };
private:
string msBody; //超人的躯体
string msSpecialTalent; //超人的特殊技能
string msSpecialSymbol; //超人的标志
};
抽象建造者
一个典型的模板方法模式,超人的各个部件(躯体、灵魂、标志)都准备好了,具体怎么组装则是由实现类来决定。
建造者模式可以创造出比较复杂的东西。所以与工厂模式的区别就是:工厂模式关注的是创建单个产品,而建造者模式则关注创建复合对象,多个部分。
class CBuilder
{
protected:
CBuilder() { mopSuperMan = new CSuperMan; };
~CBuilder();
void mvSetBody(const string &sBody) { this->mopSuperMan->mvSetBody(sBody); };
void mvSetSpecialTalent(const string &sSpecialTalent) { this->mopSuperMan->mvSetSpecialTalent(sSpecialTalent); };
void mvSetSpecialSymbol(const string &sSpecialSymbol) { this->mopSuperMan->mvSetSpecialSymbol(sSpecialSymbol); };
public:
virtual CSuperMan *mopGetSuperMan() = 0;
protected:
CSuperMan *mopSuperMan;
};
通过模版方法加上建造者模式来建造超人
class CAdultSuperManBuilder : public CBuilder
{
public:
CAdultSuperManBuilder(){};
~CAdultSuperManBuilder(){};
CSuperMan *mopGetSuperMan()
{
mvSetBody("强壮的躯体");
mvSetSpecialTalent("会飞行");
mvSetSpecialSymbol("胸前带S标记");
return mopSuperMan;
}
};
class CChildSuperManBuilder : public CBuilder
{
public:
CChildSuperManBuilder(){};
~CChildSuperManBuilder(){};
CSuperMan *mopGetSuperMan()
{
mvSetBody("强壮的躯体");
mvSetSpecialTalent("刀枪不入");
mvSetSpecialSymbol("胸前带S标记");
return mopSuperMan;
}
};
这两个具体的建造者,它们都关注了产品的各个部分,在某些应用场景下甚至会关心产品的构建顺序,即使是相同的部件,装配顺序不同,产生的结果也不同,这也正是建造者模式的意图:通过不同的部件、不同装配产生不同的复杂对象。
导演类:
class CDirector {
public:
CDirector(){};
~CDirector(){};
//两个建造者的应用
CBuilder *mopAdultBuilder = new CAdultSuperManBuilder();
//未成年超人的建造者
CBuilder *CChildBuilder = new CChildSuperManBuilder();
//建造一个成年、 会飞行的超人
CSuperMan *mopGetAdultSuperMan(){ return mopAdultBuilder->mopGetSuperMan(); }
// 建造一个未成年、 刀枪不入的超人
CSuperMan *mopGetChildSuperMan(){ return CChildBuilder->mopGetSuperMan(); }
};
int main()
{
CDirector o_director;
//建造一个成年超人
CSuperMan *op_adult = o_director.mopGetAdultSuperMan();
// 展示超人信息
cout << op_adult->msGetSpecialTalent().c_str() << endl;
return 0;
}
建造者必须关注超人的各个部件,而工厂方法模式则只关注超人的整体,这就是两者的区别。
5、原型模式(Prototype)
将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。
class Clone
{
public:
Clone(){}
virtual ~Clone(){}
virtual Clone* clone() = 0;
};
class Sheep:public Clone
{
public:
Sheep(int id, string name):Clone(),m_id(id),m_name(name)
{
}
~Sheep(){}
Sheep(const Sheep& obj)
{
memcpy(this, &obj, sizeof(Sheep));
}
Clone* clone()
{
return new Sheep(*this);
}
private:
int m_id;
string m_name;
};
public class Prototype implements Cloneable {
public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}
}
一个原型类,只需要实现Cloneable接口,覆写clone方法,此处clone方法可以改成任意的名称,因为Cloneable接口是个空接口,你可以任意定义实现类的方法名,如cloneA或者cloneB,因为此处的重点是super.clone()这句话,super.clone()调用的是Object的clone()方法,而在Object类中,clone()是native的
public class Prototype implements Cloneable, Serializable {
private static final long serialVersionUID = 1L;
private String string;
private SerializableObject obj;
/* 浅复制 */
public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}
/* 深复制 */
public Object deepClone() throws IOException, ClassNotFoundException {
/* 写入当前对象的二进制流 */
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
/* 读出二进制流产生的新对象 */
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
public SerializableObject getObj() {
return obj;
}
public void setObj(SerializableObject obj) {
this.obj = obj;
}
}
class SerializableObject implements Serializable {
private static final long serialVersionUID = 1L;
}
要实现深复制,需要采用流的形式读入当前对象的二进制输入,再写出二进制数据对应的对象。