1、定义与动机
-
定义：将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）
-
动机：
- 在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构建而成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定
- 如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？
-
个人理解：构建器模式严格来说是在Template Method方法的基础上进行拆分，将表示和构建过程相分离拆成一个更加复杂但耦合度更低的代码。
2、案例分析
- 假设需要构建一栋房子，需要墙、窗户、房顶、地板等需求，但是所需要的房子是木头还是石头还是其他材料的房子并不清楚
- 可以很容易的使用Template Method模式写出一个伪代码，解决依赖倒置问题即可。
2.1、模板方法（一）
class House{
public:
void Init(){
// 构建墙
this->BuilderWall();
// 构建四个窗户
for(int i = 0;i < 4;i++){
this->BuilderWindows();
}
// 是否需要铺地板
if(this->BuilderFlag()){
this->BuilderFloor();
}
// 构建房顶
this->BuilderRoof();
}
virtual ~House(){
}
protected:
virtual void BuilderWall() = 0;
virtual void BuilderWindows() = 0;
virtual bool BuilderFlag() = 0;
virtual void BuilderFloor() = 0;
virtual void BuilderRoof() = 0;
};
class StoneHouse: public House{
public:
virtual ~StoneHouse(){
}
protected:
virtual void BuilderWall(){
}
virtual void BuilderWindows(){
}
virtual bool BuilderFlag(){
return true;
}
virtual void BuilderFloor(){
}
virtual void BuilderRoof(){
}
};
int main()
{
House *house = new StoneHouse();
house->Init();
}
其实这个代码写到这里已经可以了，可以不继续优化也不需要使用构建器模式。
2.2、构建器模式
- 一个类的功能不能太复杂太过于庞大，当类的行为代码太多时可以考虑重构，将对象的表示和构建过程分离提取多个单独的类
- 具体思路：
- House和HouseBuilder基类，分别是一个东西的表示和构建过程
- 对于House基类可以有多种多样的House，StoneHouse、WoodHouse、CrystalHouse…
- 对于HouseBuilder基类为每种房子的构建提供具体的Builder构建器，其应该组合一个House基类
- 由于构建房子的一个基本流程（算法骨架）是大致相同（相对稳定）的，因此可以将这个大致流程（算法骨架）单独提取出一个类，通过多态的性质传入不同的XXXHouseBuilder构建器进行构建不同的房子。
class House{
protected:
Wall wall;
Window window;
public:
virtual ~House(){
}
// ...
};
class StoneHouse: public House{
public:
virtual ~StoneHouse(){
}
};
class HouseBuilder{
public:
House* GetResult(){
return house;
}
virtual ~HouseBuilder(){
}
protected:
House *house;
virtual void BuilderWall() = 0;
virtual void BuilderWindows() = 0;
virtual bool BuilderFlag() = 0;
virtual void BuilderFloor() = 0;
virtual void BuilderRoof() = 0;
};
class StoneHouseBuilder: public HouseBuilder{
protected:
virtual void BuilderWall(){
// house->wall;...
}
virtual void BuilderWindows(){
// house->window;...
}
virtual bool BuilderFlag(){
}
virtual void BuilderFloor(){
}
virtual void BuilderRoof(){
}
};
class HouseDirector{
public:
HouseBuilder* houseBuilder;
HouseDirector(HouseBuilder* _houseBuilder): houseBuilder(_houseBuilder){
}
House *Construct(){
// 构建墙
houseBuilder->BuilderWall();
// 构建四个窗户
for(int i = 0;i < 4;i++){
houseBuilder->BuilderWindows();
}
// 是否需要铺地板
if(houseBuilder->BuilderFlag()){
houseBuilder->BuilderFloor();
}
// 构建房顶
houseBuilder->BuilderRoof();
return houseBuilder->GetResult();
}
};
3、总结
- Builder模式主要用于“分步构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
- 变化点在哪里，封装哪里——Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。（稳定点就是缺点）
- Builder模式中，需要注意不同语言中构造器内部调用虚函数的差别（C++ vs Java）
- C++中无法再父类的构造方法中调用子类的虚函数（动态绑定），因为子类在此时还没有构造出来，此时如果在构造方法中调用虚函数，那么将会是静态绑定，意味着调用父类自己的虚函数。而Java等语言不是
