四、建造者模型

模式讲解： 
1. 指挥者（Director）直接和客户（Client）进行需求沟通； 
2. 沟通后指挥者将客户创建产品的需求划分为各个部件的建造请求（Builder）； 
3. 将各个部件的建造请求委派到具体的建造者（ConcreteBuilder）； 
4. 各个具体建造者负责进行产品部件的构建； 
5. 最终构建成具体产品（Product）。

优点

• 易于解耦 
  将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
• 易于精确控制对象的创建 
  将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
• 易于拓展 
  增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。 

java:

package com.shuang.build;

import com.sun.prism.image.CompoundTexture;

public abstract class Builder {
	public abstract void BuildCpu();
	public abstract void BuildMainboard();
	public abstract void BuildHD();
	public abstract Computer GetComputer();
}	

package com.shuang.build;

public class BuilderPattern {
	public static void main(String[] args) {
		Director director=new Director();
		Builder builder=new ConcreteBuilder();
		director.Construct(builder);
		Computer computer=builder.GetComputer();
		computer.Show();
	}
}

package com.shuang.build;

import java.util.ArrayList;
import java.util.List;

public class Computer {
	private List<String>parts=new ArrayList<>();
	public void Add(String part){
		parts.add(part);
	}
	public void Show(){
		for(int i=0;i<parts.size();i++){
			System.out.println("组件"+parts.get(i)+"组装好了");
		}
		System.out.println("请验收");
	}
}

package com.shuang.build;

public class ConcreteBuilder extends Builder {
	private Computer computer=new Computer();
	@Override
	public void BuildCpu() {
		computer.Add("CPU");
	}

	@Override
	public void BuildMainboard() {
		computer.Add("MainBoard");

	}

	@Override
	public void BuildHD() {
		computer.Add("HD");
	}

	@Override
	public Computer GetComputer() {
		
		return computer;
	}

}

package com.shuang.build;

public class Director {
	public void Construct(Builder builder){
		builder.BuildCpu();
		builder.BuildMainboard();
		builder.BuildHD();
	}
}

c++:

#include<iostream>
using namespace std;
#include<string>
class House
{
public:
	void setDoor(string door)
	{
		this->m_door=door;
	}
	void setWall(string wall)
	{
		this->m_wall=wall;
	}
	void setWindow(string window)
	{
		this->m_window=window;
	}
	string getWindow()
	{
		cout<<m_window<<endl;
		return m_window;
	}
	string getWall()
	{
		cout<<m_wall<<endl;
		return m_wall;
	}
	string getDoor()
	{
		cout<<m_door<<endl;
		return m_door;
	}
private:
	string m_door;
	string m_wall;
	string m_window;

};
class Builder
{
public:
	virtual void buildWall()=0;
	virtual void buildDoor()=0;
	virtual void buildWindow()=0;
	virtual House* getHouse()=0;
};
class FlatBuilder:public Builder
{
public:
	FlatBuilder()
	{
		m_house=new House;
	}
	virtual void buildWall()
	{
		m_house->setWall("flat wall");
	}
	virtual void buildDoor()
	{
		m_house->setDoor("flat door");
	}
	virtual void buildWindow()
	{
		m_house->setWindow("flat window");
	}
	virtual House* getHouse()
	{
		return m_house;
	}
private:
	House *m_house;
};
class VillaBuilder:public Builder
{
public:
	VillaBuilder()
	{
		m_house=new House;
	}
	virtual void buildWall()
	{
		m_house->setWall("villa wall");
	}
	virtual void buildDoor()
	{
		m_house->setDoor("villa door");
	}
	virtual void buildWindow()
	{
		m_house->setWindow("villa window");
	}
	virtual House* getHouse()
	{
		return m_house;
	}
private:
	House *m_house;
};
class Director
{
public:
	Director(Builder *build){
		m_build=build;
	}
	void Construct()
	{
		m_build->buildWall();
		m_build->buildWindow();
		m_build->buildDoor();
	}
private:
	Builder * m_build;
};
void main()
{
	House *house=NULL;
	Builder *builder=NULL;
	Director *director=NULL;

	builder=new VillaBuilder;
	director=new Director(builder);
	director->Construct();
	house=builder->getHouse();
	house->getWindow();
	house->getDoor();

	delete house;
	delete builder;

	system("pause");
	return ;
}