设计模式之Builder模式

Posted 2022-12-10 曾淘

概要

设计模式是一门艺术，如果真正了解这门艺术，你会发现，世界都将变得更加优美。

定义

将一个复杂的对象的创建和它的表示分离，可以让不同的创建过程，创建出不同的对象

使用场景

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的，如果想要了解更多，请详细理解下其源码

感谢大家的观看，欢迎分享和转载。。。