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总结
这次有点仓促,木有博览群书然后把精华记下来,但是我觉得这次讲解应该比前两篇都要清楚。
行文参考前一篇,没有太大的改变。感觉文章不是很吸引人,也不够深动。万事开头难,当前目标是把东西说清楚,写多了以后再考虑其他方面的提升。
希望大家多提意见,一起学习一起成长。