1解释

1.1定义

将一个复杂对象的构建与他的表示分离，使得同样的构建可以创建不同的表示。

1.2分析

首先我们看看一般的实例化对象的方法，如下面代码：

Roboter roboter = new Roboter();
roboter.setmArm("arm");
roboter.setmBody("body");
roboter.setmHead("head");
roboter.setmFoot("foot");

对于Roboter这个类，包含了对应属性的set和get函数。他的赋值（构建）和获取值（表现）是在同一个类里面完成的，这样的结构属于没有分离。

    那么，分离是怎么样的呢，如下面建造者模式的类图：

 首先有一个类定义构建的接口，他就是图中的Builder，定义了如上面的setmArm(),setmBody(),setmHead(),setmFoot()。

 然后有一个类指挥如何去构建，他是图中的Director。他解决如何去构建的问题，比如只需要构建setmArm(),setmBody()这2个属性或者只需要构建setmArm(), setmBody(),setmHead()这3个属性。

再然后有一个类来实现或者继承Builder定义的接口，负责将属性设置成不同的值，他就是图中的ConcreteBuilder。他解决构建成怎么样的问题，比如setmArm("arm")或者setmArm("not a arm")。

 建造者模式将构建分成了几个部分，通过统一的构建流程，使用不同的Derector和ConcreteBuilder就构建出了不同表现形式的对象。

1.3优势

1. 需要初始化的属性很多，防止遗漏初始化某个属性。假如Human有7个属性，大家是不是在数有没有漏掉哪个呀？

Human human = new Human();
human.setmAge("18");
human.setmDepardment("E");
human.setmHeight("170");
human.setmName("Alba");
human.setmNumber("10003021");
human.setmPhoneNumber("13194697638");

2.减少构造函数的个数，减少构造函数的的参数。大家肯定见过下面类似的代码吧，说不定你还写过呢，是不是恨死这样的代码了？

public Human(String pName) {
		this.mName = pName;
	}
	public Human(String pName, String pSex) {
		this.mName = pName;
		this.mSex = pSex;
	}
	public Human(String pName, String pSex, String pNumber) {
		this.mName = pName;
		this.mSex = pSex;
		this.mNumber = pNumber;
	}
	public Human(String pName, String pSex, String pNumber, String pDepardment){
		this.mName = pName;
		this.mSex = pSex;
		this.mNumber = pNumber;
		this.mDepardment = pDepardment;
}

3.只是为了工整美观。假如下面的初始化只有一行，大家会不会认为工整一些。（有点牵强）

Human human = new Human();
human.setmAge("18");
human.setmDepardment("E");
human.setmHeight("170");
human.setmName("Aha");
human.setmNumber("10003021");
human.setmPhoneNumber("13194697638");
human.display();

1.4使用场景

2代码实例

2.1标准写法

仿照前面建造者模式的类图，画了下面的类图，并实现之。

RoboterBuilder定义了所有属性设置的接口，并且定义了一个接口返回Roboter对象。注意，一定要有一个返回Roboter对象的方法：

public interface RoboterBuilder {
	void buildHead();
	void buildArm();
	void buildBody();
	void buildFoot();
	Roboter buildRoboter();
}

RoboterDirector定义了如何去构建对象，需要设置哪些属性。需要注意，它需要材料，就是RoboterBuilder的实现类。注意看，他调用的都是RoboterBuilder的方法，最后返回一个Roboter的对象：

public class RoboterDirector {
	public Roboter createRoboter(RoboterBuilder pBuilder) {
		pBuilder.buildHead();
		pBuilder.buildBody();
		pBuilder.buildArm();
		pBuilder.buildFoot();
		return pBuilder.buildRoboter();
	}
}

SimpleRoboterBuilder实现RoboterBuilder定义的方法，根据需要可以对属性设置不同的值。注意buildRoboter()这个方法返回一个Roboter的对象，Director需要这个方法：

public class SimpleRoboterBuilder implements RoboterBuilder {
	private Roboter mRoboter;
	public SimpleRoboterBuilder() {
		mRoboter = new Roboter();
	}
	@Override
	public void buildHead() {
		mRoboter.setmHead("head");
	}
	@Override
	public void buildArm() {
		mRoboter.setmArm("arm");
	}
	@Override
	public void buildBody() {
		mRoboter.setmBody("body");
	}
	@Override
	public void buildFoot() {
		mRoboter.setmFoot("foot");
	}
	@Override
	public Roboter buildRoboter() {
		return mRoboter;
	}
}

Roboter是一个对象，定义了相关属性还有各种set和get。这里没有重要的逻辑，可以略过这个类：

public class Roboter {
	private String mHead;
	private String mArm;
	private String mBody;
	private String mFoot;
	public String getmHead() {
		return mHead;
	}
	public void setmHead(String mHead) {
		this.mHead = mHead;
	}
	public String getmArm() {
		return mArm;
	}
	public void setmArm(String mArm) {
		this.mArm = mArm;
	}
	public String getmBody() {
		return mBody;
	}
	public void setmBody(String mBody) {
		this.mBody = mBody;
	}
	public String getmFoot() {
		return mFoot;
	}
	public void setmFoot(String mFoot) {
		this.mFoot = mFoot;
	}
}

如何使用呢，其实就是调用RoboterDirector的createRoboter()方法。假如我们需要构建其他样式的对象，修改createRoboter()这个方法或者修改SimpleRoboterBuilder这个类即可：

RoboterDirector director = new RoboterDirector();
Roboter roboter = director.createRoboter(new SimpleRoboterBuilder());

2.2常用写法

大家是不是在想“好像自己看到的建造者模式不是这个样子的，比这个要简单一些”。下面介绍另外一种写法，这种写法比较常见。

实体类中有一个内部类Builder，Builder的属性与RoboterWithBuilder的属性相对应，然后有很多Set方法，主要用于设置对应的属性。每个Set方法的返回值都是Builder,最后会有一个build()方法返回我们创建的对象。

public class RoboterWithBuilder {
	private String mHead;
	private String mArm;
	private String mBody;
	private String mFoot;
	public String getmHead() {
		return mHead;
	}
	public String getmArm() {
		return mArm;
	}
	public String getmBody() {
		return mBody;
	}
	public String getmFoot() {
		return mFoot;
	}

	private RoboterWithBuilder(Builder pBuilder) {
		mHead = pBuilder.mBuilderHead;
		mBody = pBuilder.mBuilderBody;
		mArm = pBuilder.mBuilderArm;
		mFoot = pBuilder.mBuilderFoot;
	}
	public static class Builder {
		private String mBuilderHead;
		private String mBuilderArm;
		private String mBuilderBody;
		private String mBuilderFoot;
		public Builder setmBuilderHead(String mBuilderHead) {
			this.mBuilderHead = mBuilderHead;
			return this;
		}
		public Builder setmBuilderArm(String mBuilderArm) {
			this.mBuilderArm = mBuilderArm;
			return this;
		}
		public Builder setmBuilderBody(String mBuilderBody) {
			this.mBuilderBody = mBuilderBody;
			return this;
		}
		public Builder setmBuilderFoot(String mBuilderFoot) {
			this.mBuilderFoot = mBuilderFoot;
			return this;
		}
		public RoboterWithBuilder build() {
			return new RoboterWithBuilder(this);
		}
	}
}

我们看看如何调用，调用内部类Builder的方法来设置属性，最后调用build()方法返回这个对象。（下面这样写，貌似不够工整）

RoboterWithBuilder roboter  = new RoboterWithBuilder.Builder().setmBuilderArm("arm").setmBuilderBody("body").setmBuilderHead("head").setmBuilderFoot("foot").build();

如果这样写，我可以不用去记对象有哪些构造函数，并且设置属性也很方便。

代码下载地址：https://github.com/bird7310/DesignPatternExample.git

3总结

这次有点仓促，木有博览群书然后把精华记下来，但是我觉得这次讲解应该比前两篇都要清楚。

行文参考前一篇，没有太大的改变。感觉文章不是很吸引人，也不够深动。万事开头难，当前目标是把东西说清楚，写多了以后再考虑其他方面的提升。

希望大家多提意见，一起学习一起成长。