彻底明白Android设计模式—建造者模式

将一个复杂对象的 构建和表示 分离的模型
什么意思呢，就是比如我要创建一个对象，我只需要把最重要的一些信息告诉他，他就可以帮我完成所有的事情，不需要了解具体的构建过程

接下来，我们直接实现一个建造者模式示例代码

比如，我要制造一个手机，建造者模式可以让我不用了解到具体手机怎么生产的，只需要提供手机的一些参数，比如颜色，系统等，就可以制造出一个完整的手机了。

/**
     * 手机产品实体类，定义手机的一些属性（颜色，系统）
     */
    public class Phone {
        private String color;
        private String os;

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public String getOs() {
            return os;
        }

        public void setOs(String os) {
            this.os = os;
        }
    }

    /**
     * 抽象的构建类
     */
    public abstract class Builder {
        public abstract void buildColor(String color);

        public abstract void buildOs(String os);
    }

    /**
     * 具体的构建类
     */
    public class HuaweiBuilder extends Builder {
        private Phone huaweiPhone = new Phone();

        @Override
        public void buildColor(String color) {
            huaweiPhone.setColor(color);
        }

        @Override
        public void buildOs(String os) {
            huaweiPhone.setOs(os);
        }

        public Phone getHuaweiPhone() {
            return huaweiPhone;
        }
    }

    /**
     * 导演类，导演所有的一切，构建对象的各个部分
     * 其实这就有点像什么，像做了一些简单的封装，
     * 让外面的人可以轻易的创建具体需要的对象，
     * 而不用知道里面做了啥
     */
    public class Director {
        Builder mBuilder;

        public Director(Builder builder) {
            this.mBuilder = builder;
        }

        public void constract(String color, String os) {
            mBuilder.buildColor(color);
            mBuilder.buildOs(os);
        }
    }

以上就是建造者模式完整一条链的代码了。
现在我要制造一个手机就很简单了，如下

    public void main() {
        Builder builder = new HuaweiBuilder();
        Director director = new Director(builder);
        director.constract("黄色", "Android");
    }

通过简单的传参，创建生产对象。
但是其实一般不这么做，而是通过内部类方法通过builder的一种***链式表达构建对象***，比如dialog构建等，这里也举例说明：

public static class XiaomiPhone {
        private String color;
        private String os;

        private XiaomiPhone(Builder builder) {
            this.color = builder.color;
            this.os = builder.os;
        }

        public String getColor() {
            return color;
        }

        public String getOs() {
            return os;
        }

        static class Builder {
            private String color;
            private String os;

            public Builder setColor(String color) {
                this.color = color;
                return this;
            }

            public Builder setOs(String os) {
                this.os = os;
                return this;
            }

            public XiaomiPhone builder() {
                return new XiaomiPhone(this);
            }
        }
    }

然后我们实现起来就比较简单了

public void main() {
        XiaomiPhone xiaomiPhone = new XiaomiPhone.Builder()
                .setColor("")
                .setOs("")
                .builder();
    }

在Android中的应用

哇，简直不要太常见，dialog构建怎么写的？

AlertDialog.Builder builder = new AlertDialog.Builder(this).setIcon(R.mipmap.ic_launcher).setTitle("")
                .setMessage("").setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                    
                    }
                }).setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                       
                    }
                });
        builder.create().show();

为什么用建造者模式呢？其实就是方便用户使用的时候，知道要传哪些参数，方便且正确。