建造者模式 | 8月更文挑战

前面几篇关于设计模式的文章:设计模式

这些设计模式均可归为对象建立型模式。今天咱们聊聊最后一种对象建立型模式：建造者模式（Builder Pattern）post

建造者（Builder pattern）模式的定义：将一个复杂对象的构造与它的表示分离，使一样的构建过程能够建立不一样的表示ui

建造者模式的核心是：将产品和产品建造过程解耦this

通用建造者模式

建造者模式通常适用于建立复杂且由多个部分组成的对象的场景。经过建造者模式，能够把复杂对象的建造过程抽象出来（抽象类别），客户端使用时没必要知道产品构建的细节。lua

建造者模式通常由产品、抽象建造者、具体建造者、指挥者等4个角色组成。url

Product（产品角色）：一个具体的、被构造的复杂产品对象。
Builder（抽象建造者）：建立一个 Product 对象的各个部件指定的接口/抽象类。
ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件。
Director（指挥者）：构建一个使用 Builder 接口的对象。它主要是用于建立一个复杂的对象。它主要有两个做用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。

下面用具体的场景来展现建造者模式：spa

如今咱们要建立一辆自行车。

自行车有多个部件组成，一般有：轮子、脚踏板、车身、座椅、车手把

咱们也能够建造不一样的类型的自行车，好比山地自行车、共享单车（青桔单车）等

产品角色(自行车)：

public class Bicycle {
    //轮子
    private String wheel;

    // 脚踏板
    private String pedal;

    // 车身
    private String crossbar;

    // 座椅
    private String saddle;

    // 车手把
    private String handlebars;
    
    // getter和setter省略

    @Override
    public String toString() {
        return "Bicycle{" +
                "wheel='" + wheel + ''' +
                ", pedal='" + pedal + ''' +
                ", crossbar='" + crossbar + ''' +
                ", saddle='" + saddle + ''' +
                ", handlebars='" + handlebars + ''' +
                '}';
    }
}
复制代码

抽象建造者（自行车建造者）

public interface BicycleBuilder {

    void builtWheel(String wheel);

    void builtPedal(String pedal);

    void builtCrossbar(String crossbar);

    void buildSaddle(String saddle);

    void buildHandlebars(String handlebars);

    Bicycle build();
}
复制代码

具体建造者（青桔自行车建造者）（非广告，只由于今晚骑青桔了）

public class DiDiBicycleBuilder implements BicycleBuilder {

    private Bicycle bicycle;

    public DiDiBicycleBuilder() {
        bicycle = new Bicycle();
    }

    @Override
    public void builtWheel(String wheel) {
        this.bicycle.setWheel(wheel);
    }

    @Override
    public void builtPedal(String pedal) {
        this.bicycle.setPedal(pedal);
    }

    @Override
    public void builtCrossbar(String crossbar) {
        this.bicycle.setCrossbar(crossbar);
    }

    @Override
    public void buildSaddle(String saddle) {
        this.bicycle.setSaddle(saddle);
    }

    @Override
    public void buildHandlebars(String handlebars) {
        this.bicycle.setHandlebars(handlebars);
    }

    @Override
    public Bicycle build() {
        return bicycle;
    }
}
复制代码

指挥者（自行车建立指挥者）

public class BicycleDirector {
    private BicycleBuilder builder;

    public BicycleDirector(BicycleBuilder builder) {
        this.builder = builder;
    }

    public Bicycle builtBicycle(String wheel, String pedal, String crossbar, String saddle, String handlebars) {
        builder.builtWheel(wheel);
        builder.builtPedal(pedal);
        builder.builtCrossbar(crossbar);
        builder.buildSaddle(saddle);
        builder.buildHandlebars(handlebars);
        return builder.build();
    }
}
复制代码

客户端，使用建造者模式建立自行车对象

public class Main {
    public static void main(String[] args) {
        BicycleBuilder builder = new DiDiBicycleBuilder();
        BicycleDirector director = new BicycleDirector(builder);
        Bicycle bicycle = director.builtBicycle("青桔轮子", "青桔脚踏板", "青桔车身", "舒服的座椅", "青桔车手把");
        System.out.println(bicycle);
    }
}
复制代码

链式调用建造对象

咱们常见的链式调用建立对象，其实也是利用了建造者模式。这种建造者模式，没有具体的角色，而是把建立的过程封装在Builder构建器里了。

具体的代码：

public class Bicycle {
    //轮子
    private String wheel;

    // 脚踏板
    private String pedal;

    // 车身
    private String crossbar;

    // 座椅
    private String saddle;

    // 车手把
    private String handlebars;


    private Bicycle(BicycleBuilder bicycleBuilder) {
        this.wheel = bicycleBuilder.wheel;
        this.pedal = bicycleBuilder.pedal;
        this.crossbar = bicycleBuilder.crossbar;
        this.saddle = bicycleBuilder.saddle;
        this.handlebars = bicycleBuilder.handlebars;
    }


    // 建造者，静态内部类。将建立的过程封装在建造者中
    public static class BicycleBuilder{
        //轮子
        private String wheel;
        // 脚踏板
        private String pedal;
        // 车身
        private String crossbar;
        // 座椅
        private String saddle;
        // 车手把
        private String handlebars;

        public BicycleBuilder wheel(String wheel){
            this.wheel = wheel;
            return this;
        }

        public BicycleBuilder pedal(String pedal) {
            this.pedal = pedal;
            return this;
        }

        public BicycleBuilder crossbar(String crossbar) {
            this.crossbar = crossbar;
            return this;
        }

        public BicycleBuilder saddle(String saddle) {
            this.saddle = saddle;
            return this;
        }

        public BicycleBuilder handlebars(String handlebars) {
            this.handlebars = handlebars;
            return this;
        }

        public Bicycle built() {
            return new Bicycle(this);
        }

    }

    @Override
    public String toString() {
        return "Bicycle{" +
                "wheel='" + wheel + ''' +
                ", pedal='" + pedal + ''' +
                ", crossbar='" + crossbar + ''' +
                ", saddle='" + saddle + ''' +
                ", handlebars='" + handlebars + ''' +
                '}';
    }
}
复制代码

客户端使用：

public class Main {
    public static void main(String[] args) {
        Bicycle bicycle = new Bicycle.BicycleBuilder().wheel("山地车轮子").crossbar("不锈钢车身").handlebars("减压车把").built();
        System.out.println(bicycle);
    }
}

// 输出结果：
Bicycle{wheel='山地车轮子', pedal='null', crossbar='不锈钢车身', saddle='null', handlebars='减压车把'}
复制代码