[009].第05节.建造者模式

• 由建房子引入建造者模式
• 建房的过程为打桩、砌墙、封顶，各种房子的过程虽然一样，但是要求不相同

1.传统思路:

1.1.类图：

1.2.代码实现

• 1.房子抽象类AbstractHouse

public abstract class AbstractHouse {
 
    //地基深度
    private String basic;
    //墙高度
    private String walls;
    //屋顶宽度
    private String roof;
 
    //修地基
    public abstract void buildBasic();
    
    //砌墙
    public abstract void buildWalls();
    
    //封顶
    public abstract void roofed();
   
    //盖房子整体过程
    public void build(){
        buildBasic();
        buildWalls();
        roofed();
    }
 
    //get，set，toString省略
}

• 2.高楼HighHouse

public class HighHouse extends AbstractHouse{
    @Override
    public void buildBasic() {
        setBasic("100米");
        System.out.println("高楼修地基");
    }
 
    @Override
    public void buildWalls() {
        setWalls("100米");
        System.out.println("高楼盖墙");
    }
 
    @Override
    public void roofed() {
        setRoof("100米");
        System.out.println("高楼封顶");
    }
}

• 3.客户端Client

public class Client {
    public static void main(String[] args) {
        HighHouse highHouse = new HighHouse();
        highHouse.build();
        System.out.println(highHouse)
    }
}

1.3.问题分析与解决方案:

• 这种设计方案，把产品(即：房子) 和 创建产品的过程(即：建房子流程) 封装在一起，耦合性增强了。
• 解决方案：将产品和产品建造过程解耦 => 建造者模式

---

2.建造者模式

2.1.基本介绍

• 1.通俗的讲，比如你想盖一个房子，需要修地基，砌墙，封顶，它们的地基深度，砌墙高度，封顶宽带不一样，最终的房子天差地别。
• 2.而这样的根据相同的过程，不同的组装所产生出的具体的内容，就是建造者模式的具体实现，也就是将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

2.2.建造者模式的四个角色

• 1.Product（产品角色）：具体的产品对象。
• 2.Builder（抽象建造者）：声明创建一个Product对象的各个部件的抽象接口，该接口中一般声明两类方法，一类方法是buildPatX()，用于创建复杂对象的各个部件，另一类方法是getResult()，用于返回复杂对象。Builder既可以是抽象类，也可以是接口。
• 3.ConcreteBuilder（具体建造者）：实现接口，不同的建造者对于各个部件的制作不一样，这里只完成了各个部件的制作，具体的拼接则在指挥者里。
• 4.Director（指挥者）：负责安排复杂对象的建造次序，指挥者与抽象者之间存在关联关系，可以在其construct()构造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交换，在客户端确定具体建造者的类型，然后通过指挥者类的构造函数或者setter方法将该对象传入指挥者类中。它主要有两个作用①隔离了客户与对象的生产过程②负责控制产品对象的生产过程

2.3.代码实现

• 1.具体思路
  
• 2.产品:

public class House {
    //地基深度
    private String basic;
    //墙高度
    private String walls;
    //屋顶宽度
    private String roof;
 
    //省略get,set,toString
}

• 3.抽象建造者

public abstract class HouseBuilder{
    //将产品组合过来;
    //用protected;可以让同包下的类以及子类去访问;
    protected House house = new House();
 
    //地基
    public abstract void buildBasic();
 
    //砌墙
    public abstract void buildWalls();
 
    //封顶
    public abstract void roofed();
 
    //盖房子;==>(房子盖好了)返回产品
    public House getResult(){
        return house;
    }
}

• 具体建造者

public class HighHouse extends HouseBuilder{
 
    @Override
    public void buildBasic() {
        house.setBasic("100米");
        System.out.println("高楼修地基");
    }
 
    @Override
    public void buildWalls() {
        house.setWalls("100米");
        System.out.println("高楼盖墙");
    }
 
    @Override
    public void roofed() {
        house.setRoof("100米");
        System.out.println("高楼封顶");
    }
}

public class CommonHouse extends HouseBuilder{
 
    @Override
    public void buildBasic() {
        house.setBasic("5米");
        System.out.println("普通房子修地基");
    }
 
    @Override
    public void buildWalls() {
        house.setWalls("5米");
        System.out.println("普通房子盖墙");
    }
 
    @Override
    public void roofed() {
        house.setRoof("5米");
        System.out.println("普通房子封顶");
    }
}

• 指挥者

public class HouseDirector {
    private HouseBuilder houseBuilder;
    //构造器传入;
    public HouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder=houseBuilder;
    }
 
    public HouseDirector(){
        
    }
 
    //set方法传入;
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }
 
    //建造房子的流程;
    public House constructHouse(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.getResult();
    }
}

• 客户端

public class Client {
    public static void main(String[] args) {
        //指挥者
        HouseDirector houseDirector = new HouseDirector();
 
        //建普通房
        CommonHouse commonHouse = new CommonHouse();
        houseDirector.setHouseBuilder(commonHouse);
        House house = houseDirector.constructHouse();
        System.out.println(house);
 
        //建高楼
        HighHouse highHouse = new HighHouse();
        houseDirector.setHouseBuilder(highHouse);
        House house1 = houseDirector.constructHouse();
        System.out.println(house1);
    }
}

---

3.使用建造者模式的jdk案例

• 1.抽象建造者是Appendable接口，它定义了抽象方法。

public interface Appendable {
 
    Appendable append(CharSequence csq) throws IOException;
 
    Appendable append(CharSequence csq, int start, int end) throws IOException;
 
    Appendable append(char c) throws IOException;
}

• 抽象类AbstractStringBuilder已经完成了方法的具体实现，它作为建造者但是不能构建实例对象

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    @Override
    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        if (s == null)
            s = "null";
        if ((start < 0) || (start > end) || (end > s.length()))
            throw new IndexOutOfBoundsException(
                "start " + start + ", end " + end + ", s.length() "
                + s.length());
        int len = end - start;
        ensureCapacityInternal(count + len);
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        count += len;
        return this;
    }
 
    @Override
    public AbstractStringBuilder append(char c) {
        ensureCapacityInternal(count + 1);
        value[count++] = c;
        return this;
    }
 
    // Documentation in subclasses because of synchro difference
    @Override
    public AbstractStringBuilder append(CharSequence s) {
        if (s == null)
            return appendNull();
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof AbstractStringBuilder)
            return this.append((AbstractStringBuilder)s);
 
        return this.append(s, 0, s.length());
    }

StringBulider继承了抽象类AbstractStringBuilder

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
StringBulider在重写方法时，又去调用了父类的方法。

StringBulider 作为指挥者，也是具体建造者。

    @Override
    public StringBuilder append(CharSequence s) {
        super.append(s);
        return this;
    }
 
    @Override
    public StringBuilder append(CharSequence s, int start, int end) {
        super.append(s, start, end);
        return this;
    }
 
    @Override
    public StringBuilder append(char c) {
        super.append(c);
        return this;
    }

4.建造者模式的注意事项和细节

• 1.客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
• 2.每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象
• 3.可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰， 也更方便使用程序来控制创建过程
• 4.增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合 “开闭原则”
• 5.建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 6.如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式。

5.抽象工厂模式 VS 建造者模式

• 1.抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。
• 2.而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。