http://blog.csdn.net/lovelion/article/details/17517213
我做的这部分笔记,鉴于自身水平有限,我只是对上面博客内做进一步提炼和记录,方便自己查阅。同时,更多的是对设计模式的框架进行学习,大部分细节都将略去,让自己侧重对每个设计模式框架的理解。
我应该理解和掌握的:
1)能够画出这个设计模式的架构框图;
2)能够根据架构框图写出对应的伪代码;
3)这个模式的应用场景,主要优缺点。
1.建造者模式
建造者模式是较为复杂的创建型模式,他将客户端与包含多个组成部分(或部件)的复杂对象的创建过程分离,客户端无需知道复杂对象的内部组成部分与装配方式,只需要知道所需建造者的类型即可。
(1)定义
建造者模式:将一个复杂对象的构建和他的表示分离,使得同样的构建过程可以创建不同的表示。建造者模式一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建他们,用户不需要知道内部的具体构建细节。
建造者模式结构图:
参与者:
1)Builder(抽象建造者):它为创建一个产品Product对象的各个部件指定抽象接口。
2)ConceteBuilder(具体建造者):实现Builder接口,实现各个部件的具体构造和装配方法。
3)Product(产品角色):它是被构建的复杂对象,包含多个组件,属性;具体建造者创建该产品的内部表示并定义他的装配过程。
4)Director(指挥者):负责安排复杂对象的构造次序,与建造泽关联。
所谓的复杂对象是指那些包含多个成员属性的对象,这些成员属性也称为部件或零件。
主要的作用是,我们随时可以更换builer,不同的建造者创建不同属性的Product,所以客户端只需要更换builder就可以创建不同的产品,同时也符合开闭原则。
看图写代码:
class Producr
{
public:
Producr();
~Producr();
void setPartA(int a);
void setPartB(int b);
void setPartC(int c);
private:
int partA;
int partB;
int partC;
};
Producr::Producr()
{
}
Producr::~Producr()
{}
void Producr::setPartA(int a)
{
partA = a;
}
void Producr::setPartB(int b)
{
partB = b;
}
void Producr::setPartC(int c)
{
partC = c;
}
class Builder
{
public:
/*抽象建造者,声明一系列部件的方法,由子类实现*/
virtual void createProducr() = 0;
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual void buildPartC() = 0;
virtual Producr* getResult() = 0;
};
class ConcreteBuilder:piubli Builder{
public:
ConcreteBuilder();
~ConcreteBuilder();
//create a product
void createProducr();
//build the para of product
void buildPartA();
void buildPartB();
void buildPartC();
//return a product
Producr* getResult();
private:
Producr* m_product;
};
ConcreteBuilder::ConcreteBuilder()
{}
ConcreteBuilder::~ConcreteBuild()
{}
/*通过调用产品本身的方法设置属性*/
void ConcreteBuilder::createProducr()
{
m_product = new Producr();
}
void ConcreteBuilder::buildPartA()
{
cout<<"build product partA";
m_product->setPartA(1);
}
void ConcreteBuilder::buildPartB()
{
cout<<"build product partB";
m_product->setPartB(2);
}
void ConcreteBuilder::buildPartC()
{
cout<<"build product partC";
m_product->setPartC(3);
}
Producr* ConcreteBuilder::getResult()
{
return m_product;
}
/*作用一是隔离了客户与创建过程
二是控制产品的创建过程,方法是否需要调用,次序等
这些客户无需了解,只需要知道具体建造者就可以了。
*/
class Director
{
public:
Director(Builder builder);//注入builder
~Director();
void setBuiler(Builder* b);
Producr* contruct(Builder builder);
private:
Builder builer;
};
Director::Director(Builder builder)
{
this.builder = builder;
}
Director::~Director()
{}
void Director::setBuiler(Builder* b)
{
this.builder = b;
}
Producr* Director::contruct()
{
if(!builder)
return;
builder->createBuiler();
builder->buildPartA();
builder->buildPartB();
builder->buildPartC();
return builder->getResult();
}
int main()
{
Builder builder = new ConceteBuilder();
Director dt = new Director(builer);
Producr* pd = dt->contruct();
return 0;
}
(2)总结
1)客户端不需要知道内部组成细节,实现产品本身与产品的创建过程的解耦,使相同的创建过程可以创建不同的产品。
2)每一个建造者都相对独立,可以替换或增加新的具体建造者,得到不同的产品。指挥者类针对抽象编程,不必修改原有代码,易扩展,符合开闭。
3)可以更加精细的控制产品的创建过程。
(3)适用场景
1)需要生成的产品有复杂的内部结构,通常指包含多个成员属性的对象。
2)需要生成的产品对象的属性相互依赖,需要指定其生成顺序。
3)将创建过程封装在指挥者类中,对象的创建独立于创建该对象的类。
4)隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同的产品。