android 建造者设计模式

定义:
将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
比如说你爸是马云,你想在杭州买个别墅,你只会把你心中想象的美好的房子跟设计师讲下,让设计师去设计,难道你还会找个包工头说我房子结构是这样的,那只能说包工头爽了,他自己把设计师的钱拿了,然后找了一个不知名的设计师随便给你设计一个,具体房子的建造还是像我一样的农民工去造了,
从上面的例子中关于房子的结构(很复杂的哦)马云太子在意这个么,他在意的是设计师设计的图纸,关于农民工兄弟怎么去建造肯定不是他关心的问题,付钱就行了.
建构过程:房子怎么造
表示:房子具体的结构
来个别墅的图吧,虽然买不起!



从上面的例子中就可以抽象出四个对象了



现在看下建造者角色分配:

1:Builder：为创建一个产品对象的各个部件指定抽象接口。
2:ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
3:Director：构造一个使用Builder接口的对象，指导构建过程。
4:Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口

对应上面四个对象就是：
农名工是Builder(要求房子要先搭建地基 然后再进行一些其他的要求等)
别墅就是Product
设计师就是Director(他会把设计图给包工头看,指导包工头怎么做,一些关键点)
农民工就是ConcreteBuilder(房子的真正建造者)
现在用代码如下:

package com.example.builder;
/**
* 抽象建造者
* Created by Adminis on 2017/6/10.
*/
public interface Builder {
void createSubgrade();
void makeWindow();
void makeFloor();
void makeKitchen();
Cottage get();
}

别墅:

package com.example.builder;
/**
* 别墅
* Created by Adminis on 2017/6/10.
*/
public class Cottage {
private String window;
private String floor;
private String kitchen;
private String subgrade;
public String getSubgrade() {
return subgrade;
}
public void setSubgrade(String subgrade) {
this.subgrade = subgrade;
}
public String getWindow() {
return window;
}
public void setWindow(String window) {
this.window = window;
}
public String getFloor() {
return floor;
}
public void setFloor(String floor) {
this.floor = floor;
}
public String getKitchen() {
return kitchen;
}
public void setKitchen(String kitchen) {
this.kitchen = kitchen;
}
@Override
public String toString() {
return "房子{" +
"窗户='" + window + '\'' +
", 地板='" + floor + '\'' +
", 厨房='" + kitchen + '\'' +
", 地基='" + subgrade + '\'' +
'}';
}
}

设计师:

package com.example.builder;
/**
* 设计师
* Created by Adminis on 2017/6/10.
*/
public class Designer {
public Cottage build(Builder builder){//指导农民工去建造房子
builder.createSubgrade();
builder.makeFloor();
builder.makeWindow();
builder.makeKitchen();
return builder.get();
}
}

包工头:

package com.example.builder;
/**
* 包工头
* Created by Adminis on 2017/6/10.
*/
public class WorkerBuilder implements Builder{
private Cottage cottage = new Cottage();
@Override
public void createSubgrade() {
cottage.setSubgrade("氟利昂黄");
}
@Override
public void makeWindow() {
cottage.setWindow("欧洲分格的吊窗");
}
@Override
public void makeFloor() {
cottage.setFloor("马可波罗地板");
}
@Override
public void makeKitchen() {
cottage.setKitchen("格力厨房");
}
@Override
public Cottage get() {
return cottage;
}
}

公子哥:

package com.example.builder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
/**
* 马云的公子
*/
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Designer designer = new Designer();
Builder builder =  new WorkerBuilder();
Cottage cottage = designer.build(builder);//这房子造好了给公子哥
Log.e("MainActivity",cottage.toString());
}
}

在这里农民工就和包工头是同一个角色了.

上面的代码类图如下:



现在对这个建造者进行变形,实际的过程中也是这么干的,比如ImageLoader框架中配置一些信息,比如加载失败现实的的图片,缓存策略等,就是使用了建造者模式,这其实是省略了设计师这个角色,这导致直接下岗了.
上面的别墅(Cottage)对外有set()方法,这样用户自己都可以建房子了,干嘛还给钱给你啊,这是不合理的，这也违背了该模式的之前的定义:
现在对其变形如下:

package com.example.builder.compare;
/**
* 包工头
* Created by Adminis on 2017/6/10.
*/
public class Builder {
private CottageExtra cottageExtra;
public Builder() {
cottageExtra = new CottageExtra();
}
public Builder createSubgrade(String subgrade) {
cottageExtra.subgrade = subgrade;
return this;
}
public Builder makeWindow(String window) {
cottageExtra.window = window;
return this;
}
public Builder makeFloor(String floor) {
cottageExtra.floor = floor;
return this;
}
public Builder makeKitchen(String kitchen) {
cottageExtra.kitchen = kitchen;
return this;
}
public Cottage get() {
Cottage cottage = new Cottage();
cottage.apply(cottageExtra);
return cottage;
}
//类中的属性要和Cottage一致 这内部类就是防止在Cottage中写set方法
class CottageExtra{
public String window;
public String floor;
public String kitchen;
public String subgrade;
}
}

这是构建者:

package com.example.builder.compare;
/**
* 别墅
* Created by Adminis on 2017/6/10.
*/
public class Cottage {
private String window;
private String floor;
private String kitchen;
private String subgrade;
//隐藏构建过程
public Cottage apply(Builder.CottageExtra cottageExtra){
window = cottageExtra.window;
floor = cottageExtra.floor;
kitchen = cottageExtra.kitchen;
subgrade = cottageExtra.subgrade;
return this;
}
}

使用:

package com.example.builder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import com.example.builder.compare.Builder;
import com.example.builder.compare.Cottage;
/**
* 马云的公子
*/
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Cottage cottage=(new Builder()).makeWindow("欧美吊篮").makeFloor("马可波罗地板").makeKitchen("小黄人厨房").createSubgrade("知名地基").get();; //获取工人对象
}
}

这就是我们常见的链式调度了.

这和我们的android中的StringBuilder和AlertBuilder很像,其实都是使用建造者模式,看下StringBuilder源码:

public StringBuilder append(int i) {
super.append(i);
return this;
}

public StringBuilder append(long lng) {
super.append(lng);
return this;
}

public StringBuilder append(float f) {
super.append(f);
return this;
}

public StringBuilder append(double d) {
super.append(d);
return this;
}

这就是我们为什么可以一直调用append()方法,因为他把自己返回了.

睡觉吧.