java23种设计模式-创建型模式-建造者模式

一、定义

　　建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

　　一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

 

二、优点及缺点

优点： 

　1、建造者独立，易扩展。

   2、便于控制细节风险。

缺点：

　 1、产品必须有共同点，范围有限制。

　 2、如内部变化复杂，会有很多的建造类。

 

三、代码实现：

 实体类（产品）：

/**
 *  @author: wsq
 *  @Date: 2020/9/22 20:07
 *  @Description: 实体类
 */
public class Bike {
    // 车轮
    private String wheel;
    // 车把
    private String handlebar;
    // 车身
    private String body;

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getHandlebar() {
        return handlebar;
    }

    public void setHandlebar(String handlebar) {
        this.handlebar = handlebar;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    @Override
    public String toString() {
        return "Bike{" +
                "wheel='" + wheel + '\'' +
                ", handlebar='" + handlebar + '\'' +
                ", body='" + body + '\'' +
                '}';
    }
}

 

创建者：

/**
 *  @author: wsq
 *  @Date: 2020/9/22 20:10
 *  @Description: 建造者
 */
public class Builder {
    private Bike bike = new Bike();
    public void setWheel(String wheel){
        bike.setWheel(wheel);
    }
    public void setHandlebar(String handlebar){
        bike.setHandlebar(handlebar);
    }
    public void setBody(String body){
        bike.setBody(body);
    }
    public Bike buildBike(){
        return bike;
    }
}

 

指挥者：

/**
 * @author: wsq
 * @Date: 2020/9/22 20:15
 * @Description: 指挥者
 */
public class Director {
    public Bike getNoWheelBike() {
        Builder builder = new Builder();
        builder.setHandlebar("车把");
        builder.setBody("车身");
        return builder.buildBike();
    }

    public Bike getNoHandlebarBike() {
        Builder builder = new Builder();
        builder.setWheel("车轮");
        builder.setBody("车身");
        return builder.buildBike();
    }
}

 

测试类：

/**
 *  @author: wsq
 *  @Date: 2020/9/22 20:19
 *  @Description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        Director director = new Director();
        // 无轮子的车子
        Bike noWheelBike = director.getNoWheelBike();
        System.out.println(noWheelBike.toString());
        // 无车把的车子
        Bike noHandlebarBike = director.getNoHandlebarBike();
        System.out.println(noHandlebarBike.toString());
    }
}

 

四、源码级别

 今天来补一下建造者模式的JDK源码

大家对StringBuilder并不陌生，它就使用到了建造者模式，现在先看一下测试类

/**
 *  @author: wsq
 *  @Date: 2020/9/22 20:19
 *  @Description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder().append("This").append("is").append("a").append("good").append("boy");
    }
}

无论你使用多少次append都是可以的，产生的对象都是StringBuilder类型的，你可以控制它的创建过程，可以根据需求自由的组装。

可以简单的看一眼源码：

 

 这个ensureCapacityInternal方法是用来对数组进行动态扩容的

 

 

minimumCapacity是使用长度+传入字符串长度的总和，如果现有数组的长度小于mininumCapacity，那么就对数组进行扩容。

之后就行将新字符串整到数组里面就ok了。

五、总结

使用场景： 

　　1、需要生成的对象具有复杂的内部结构。

　    2、需要生成的对象内部属性本身相互依赖

注意事项：产品族难扩展，产品等级易扩展。