个人技术分享

---

前言

本文主要学习建造者模式，建造者模式使用多个简单的对象，一步一步构建一个复杂的对象，允许按指定要求构建对应对象。

---

一、介绍

建造者设计模式，封装一个对象的构造过程，使用多个简单的对象一步一步构建成一个复杂的对象，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

二、详细分析

1.核心组成

• Builder：抽象建造者，定义多个通用方法和构建方法；
• ConcreteBuilder：具体建造者，可以有多个；
• Director：指挥者，控制整个组合过程，将需求交给建造者，由建造者去创建对象；
• Product：产品角色。
  

2.实现步骤

1.创建具体产品类；
2.创建抽象建造者，构建产品属性；
3.创建具体的建造者可有有多个（实现抽象建造者），根据自己的需求来定；
4.创建指挥者，进行创建产品类；

3.代码示例

具体产品类：

/**
 * 产品
 */
public class IphoneProduct {

    /**
     * 颜色
     */
    private String colour;

    /**
     * 屏幕尺寸
     */
    private double screenSize;

    /**
     * 手机内存
     */
    private int memory;

    /**
     * 运行内存
     */
    private int cpu;

    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }

    public double getScreenSize() {
        return screenSize;
    }

    public void setScreenSize(double screenSize) {
        this.screenSize = screenSize;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getCpu() {
        return cpu;
    }

    public void setCpu(int cpu) {
        this.cpu = cpu;
    }

    @Override
    public String toString() {
        return "IphoneProduct{" +
                "colour='" + colour + '\'' +
                ", screenSize=" + screenSize +
                ", memory=" + memory +
                ", cpu=" + cpu +
                '}';
    }
}

抽象建造者：

/**
 * 抽象建造者
 */
public interface IphoneBuilder {


    /**
     * 颜色
     */
    void colour();

    /**
     * 屏幕尺寸
     */
    void screenSize();

    /**
     * 机身内存
     */
    void memory();

    /**
     * 运行内存
     */
    void cpu();

    /**
     * 创建手机
     * @return
     */
    IphoneProduct createIphone();

}

具体建造者：

/**
 * 具体建造者
 */
public class HighIphoneBuilder implements IphoneBuilder{
    private IphoneProduct iphoneProduct = new IphoneProduct();

    @Override
    public void colour() {
        iphoneProduct.setColour("星光色");
    }

    @Override
    public void screenSize() {
        iphoneProduct.setScreenSize(6.1);
    }

    @Override
    public void memory() {
        iphoneProduct.setMemory(256);
    }

    @Override
    public void cpu() {
        iphoneProduct.setCpu(6);
    }

    @Override
    public IphoneProduct createIphone() {
        return iphoneProduct;
    }
}

/**
 * 具体建造者
 */
public class LowIphoneBuilder implements IphoneBuilder{

    private IphoneProduct iphoneProduct = new IphoneProduct();

    @Override
    public void colour() {
        iphoneProduct.setColour("星光色");
    }

    @Override
    public void screenSize() {
        iphoneProduct.setScreenSize(5.4);
    }

    @Override
    public void memory() {
        iphoneProduct.setMemory(128);
    }

    @Override
    public void cpu() {
        iphoneProduct.setCpu(4);
    }

    @Override
    public IphoneProduct createIphone() {
        return iphoneProduct;
    }
}

指挥者：

/**
 * 指挥者，负责让建造者创建对象
 */
public class DirectorIphoneBuild {

    /**
     * 创建对象
     * @param iphoneBuilder
     * @return
     */
    public IphoneProduct craete(IphoneBuilder iphoneBuilder){
        iphoneBuilder.colour();
        iphoneBuilder.screenSize();
        iphoneBuilder.memory();
        iphoneBuilder.cpu();
        return iphoneBuilder.createIphone();
    }

}

测试类：

/**
 * 测试类
 */
public class BuilderTest {
    public static void main(String[] args) {
        DirectorIphoneBuild directorIphoneBuild = new DirectorIphoneBuild();
        IphoneProduct lowIphone = directorIphoneBuild.craete(new LowIphoneBuilder());
        System.out.println(lowIphone.toString());
    }
}

结果：

4.优缺点

优点

• 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦；
• 易于精确控制对象的创建，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
• 易于拓展，增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

缺点

• 建造者模式所创建的产品一般具有较多的共同点，如果产品差异大则不建议使用。

5.使用场景

• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

---

总结

以上就是今天要讲的内容，本文主要介绍了，建造者模式的核心组成，实现步骤，代码示例和使用场景。