概要
设计模式是一门艺术,如果真正了解这门艺术,你会发现,世界都将变得更加优美。
定义
将一个复杂的对象的创建和它的表示分离,可以让不同的创建过程,创建出不同的对象
使用场景
1.相同的构造,不同的执行方法,产生不同的对象,比如:Dialog
2.多种零件,组成一个对象中,产出不同的结果
3.产品复杂,顺序不同,有不懂的结果
4.初始化对象,参数很多,但是有些是默认的,比如ImageLoader
UML
UML图,很简单,最重要的只有一个Builder,我们会里用该Builder去创建,设置完成调用,生产不同的Nexus(google手机)出来,没什么可将的,里面可以设置cpu,内存,系统版本等
代码演示
(1)抽象Builder
package com.zengtao.demo.dialog;
/**
* 抽象构建器 - 规范产品的组成,由子类去实现
*/
public abstract class Builder {
public abstract void setRam(String ram);
public abstract void setCpu(String cpu);
public abstract void setOS(String os);
public abstract void show();
}
(2)具体Builder
package com.zengtao.demo.dialog;
/**
* 具体构建器
*/
public class NexusBuilder extends Builder {
private Phone phone = new Nexus5();
@Override
public void setRam(String ram) {
phone.setRam(ram);
}
@Override
public void setCpu(String cpu) {
phone.setCpu(cpu);
}
@Override
public void setOS(String os) {
phone.setOS(os);
}
@Override
public void show() {
phone.show();
}
}
(3)抽象手机
package com.zengtao.demo.dialog;
/**
* 抽象手机 - 手机的组成
*/
public abstract class Phone {
private String ram = "16G";
private String cpu = "8核";
public abstract void setOS(String os);
public abstract String getOS();
public void setRam(String ram) {
this.ram = ram;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public void show() {
StringBuffer sb = new StringBuffer();
sb.append("Phone配置如下");
sb.append("\n\n");
sb.append("RAM = " + ram);
sb.append("\n");
sb.append("CPU = " + cpu);
sb.append("\n");
sb.append("OS = " + getOS());
sb.append("\n\n");
sb.append("Phone生产完成");
System.out.println(sb.toString());
}
}
(4)具体手机
package com.zengtao.demo.dialog;
/**
* 具体手机Nexus5
*/
public class Nexus5 extends Phone {
private String os;
@Override
public void setOS(String os) {
this.os = os;
}
@Override
public String getOS() {
return os;
}
}
(5)调用
package com.zengtao.demo;
import com.zengtao.demo.dialog.Compose;
import com.zengtao.demo.dialog.NexusBuilder;
public class Main {
public static void main(String[] str) {
NexusBuilder nexusBuilder = new NexusBuilder();
Compose compose = new Compose(nexusBuilder);
compose.buildUp();
}
}
(6)结果
会产生一款默认的Nexus手机
(7)设置自定义的
package com.zengtao.demo;
import com.zengtao.demo.dialog.Compose;
import com.zengtao.demo.dialog.NexusBuilder;
public class Main {
public static void main(String[] str) {
NexusBuilder nexusBuilder = new NexusBuilder();
nexusBuilder.setOS("Nexus 6.0.1");
nexusBuilder.setRam("128G");
Compose compose = new Compose(nexusBuilder);
compose.buildUp();
}
}
(7)结果
那么,我们就会生产自己想要的Nexus
好了,总体上说来,就是使用Buidler模式,可以解决,创建一个复杂的对象,可以将它和实现分离,自己完成自己的。
接下来,我们在讲解下,平时我们用到的Builder模式,最简单一个就是Dialog,我们在使用Dialog的时候,可能是这样:
progressDialog = new MaterialDialog.Builder(this)
.title(title)
.content(content)
.progress(true, 0)
.cancelable(false)
.show();
大家发现没有,这个Dialog是利用builder创建,然后不停的调用方法,但是可以乱序的调用,然后生成自己想要的Dialog,那么这个到底是怎么实现的呢?那么接下里我会利用伪代码,给大家展现下:
(1)抽象Builder
package com.zengtao.demo.dialog;
/**
* 抽象Dialog
*/
public abstract class Dialog {
public abstract void setTitle(String title);
public abstract void setContent(String content);
public abstract void setOk(String ok);
public abstract void setCancel(String cancel);
public abstract void isCancel(boolean isShow);
public abstract void show();
}
里面的内容很清楚,我们可以
1.设置标题
2.设置内容
3.确定按钮
4.取消按钮
5.show
(2)具体Dialog
package com.zengtao.demo.dialog;
/**
* MaterialDialog
*/
public class MaterialDialog extends Dialog {
@Override
public void setTitle(String title) {
System.out.println("MaterialDialog 标题:" + title);
}
@Override
public void setContent(String content) {
System.out.println("MaterialDialog 内容:" + content);
}
@Override
public void setOk(String ok) {
System.out.println("MaterialDialog ok按钮:" + ok);
}
@Override
public void setCancel(String cancel) {
System.out.println("MaterialDialog 取消按钮:" + cancel);
}
@Override
public void isCancel(boolean isShow) {
System.out.println("MaterialDialog 是否显示取消按钮: " + isShow);
}
@Override
public void show() {
System.out.println("MaterialDialog 显示");
}
public static class Builder {
private String title;
private String content;
private String ok;
private String cancel;
private boolean isCancel;
public Builder() {
}
public Builder setTitle(String title) {
this.title = title;
return this;
}
public Builder setContent(String content) {
this.content = content;
return this;
}
public Builder setOk(String ok) {
this.ok = ok;
return this;
}
public Builder setCancel(String cancel) {
this.cancel = cancel;
return this;
}
public Builder isCancel(boolean isCancel) {
this.isCancel = isCancel;
return this;
}
public MaterialDialog show() {
MaterialDialog dialog = new MaterialDialog();
dialog.setTitle(title);
dialog.setContent(content);
dialog.setOk(ok);
dialog.setCancel(cancel);
dialog.isCancel(isCancel);
dialog.show();
return dialog;
}
}
}
具体Dialog,是怎么样的呢,我们看代码
它是在内部定义了一个静态内部类,也就是Builder,我们可以在Builder里面进行各种构造,然后会根据构造的不同,生成不同个Dialog,比如:
1.没有取消按钮的
2.自定义标题
3.没有内容的等等
(3)调用
package com.zengtao.demo;
import com.zengtao.demo.dialog.MaterialDialog;
public class Main {
public static void main(String[] str) {
MaterialDialog.Builder builder = new MaterialDialog.Builder();
builder.setTitle("MateriaDialog")
.setContent("MateriaDialog Merge")
.setOk("确定")
.isCancel(false)
.setCancel("取消")
.show();
}
}
(4)结果
在这里,大家会看到,我们自定义的MaterialDialog是不是用我们刚刚学习的Builder模式实现了,当然,这个是伪代码,大家如果想真的实现,可以去尝试下,当然,可以走捷径,比如:在Github上是有MaterialDialog的,可以导入项目,自己看下源码
在实际过程中使用到的还有很多,在文章最开头,我也解释了,比如ImageLoader,也是使用了Builder的,如果想要了解更多,请详细理解下其源码
感谢大家的观看,欢迎分享和转载。。。