Android-设计模式-建造者模式

1.定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2.介绍

• 建造者模式属于创建型模式。
• 建造者模式主要用来创建复杂的对象，用户可以不用关心其建造过程和细节。
• 例如：当要组装一台电脑时，我们选择好CPU、内存、硬盘等等，然后交给装机师傅，装机师傅就把电脑给组装起来，我们不需要关心是怎么拼装起来的。

 

3.UML类图

4.实现

4.1 定义具体的产品类（Product）：电脑

public class Computer {
    private String mCPU;
    private String mMemory;
    private String mHD;

    public void setCPU(String CPU) {
        mCPU = CPU;
    }

    public void setMemory(String memory) {
        mMemory = memory;
    }

    public void setHD(String HD) {
        mHD = HD;
    }
}

4.2 定义抽象建造者（Builder）：组装电脑的过程

public abstract class Builder {
    public abstract void buildCPU(String cpu);//组装CPU

    public abstract void buildMemory(String memory);//组装内存

    public abstract void buildHD(String hd);//组装硬盘

    public abstract Computer create();//返回组装好的电脑
}

4.3 创建具体的建造者（ConcreteBuilder）：装机人员

public class ConcreteBuilder extends Builder {
    //创建产品实例
    private Computer mComputer = new Computer();

    @Override
    public void buildCPU(String cpu) {//组装CPU
        mComputer.setCPU(cpu);
    }

    @Override
    public void buildMemory(String memory) {//组装内存
        mComputer.setMemory(memory);
    }

    @Override
    public void buildHD(String hd) {//组装硬盘
        mComputer.setHD(hd);
    }

    @Override
    public Computer create() {//返回组装好的电脑
        return mComputer;
    }
}

4.4 定义指挥者类（Director）：老板委派任务给装机人员

public class Director {
    private Builder mBuild = null;

    public Director(Builder build) {
        this.mBuild = build;
    }

    //指挥装机人员组装电脑
    public void Construct(String cpu, String memory, String hd) {
        mBuild.buildCPU(cpu);
        mBuild.buildMemory(memory);
        mBuild.buildHD(hd);
    }
}

4.5 测试方法

   public void CreatComputer() {
        Builder builder = new ConcreteBuilder();//创建建造者实例，（装机人员）
        Director direcror = new Director(builder);//创建指挥者实例，并分配相应的建造者，（老板分配任务）
        direcror.Construct("i7-6700", "三星DDR4", "希捷1T");//组装电脑
    }

5.应用场景

• 创建一些复杂的对象时,对象内部的构建过程存在复杂变化。
• 相同的构建过程，不同的执行顺序，产生不同结果时。
• 不同配置的构建对象，产生不同结果时。

6.优点

• 封装性良好，隐藏内部构建细节。
• 易于解耦，将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
• 易于扩展，具体的建造者类之间相互独立，增加新的具体建造者无需修改原有类库的代码。
• 易于精确控制对象的创建，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

7.缺点

• 产生多余的Build对象以及Director类。
• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

8.链式调用

当然我们可以将Director、Builder角色直接省略掉，直接进行组装，这个就是我们常见到的链式调用，我们只需要将产品类改下，我们看下具体的代码实现：

public class Computer {
    //CPU类型
    private String mCPU;
    //内存类型
    private String mMemory;
    //硬盘类型
    private String mHD;

    public void setCPU(String CPU) {
        this.mCPU = CPU;
        return this;
    }

    public void setMemory(String memory) {
        this.mMemory = memory;
        return this;
    }

    public void setHD(String HD) {
        this.mHD = HD;
        return this;
    }
    @Override
    public String toString() {
        return mCPU + mMemory + mHD;
    }
} 

我们可以看到只要对setter方法进行改造都返回当前对象，即return this这样我们就可以使用链式调用了

    public class Client {
        public static void main(String[] args) {
            Computer computer = new computer().setCPU("CPU：i7-6700，")
                    .setMemory("内存：三星DDR4，")
                    .setHD("外存：希捷1T。");
            System.out.println(computer.toString());
        }
    }

输出的结果还是和上面的一样，这种方式不仅去除了Director角色，整个结构更加简单，组装过程也更加简单，更容易控制。

 

• 原作者：四月葡萄-----https://www.jianshu.com/p/154948d5adc6
• 另外的参考文章：茄子_土豆-----https://blog.csdn.net/weixin_41955327/article/details/92145734