23种设计模式——建造者模式

建造者模式：又叫生成器模式，他将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构建出不同的表现对象。
四个角色：
Product（产品角色）：一个具体的产品对象。
Builder（抽象建造者）：创建一个Product对象的各个部件指定的接口/抽象类。
ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件。
Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程。二是：负责产品对象的生产过程。

建造者模式原理类图：

不使用建造者模式建房子，普通建房子的思路：

public class House {
    private String baise;
    private String wall;
    private String roofed;

    public String getBaise() {
        return baise;
    }

    public void setBaise(String baise) {
        this.baise = baise;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "baise='" + baise + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

public abstract class BuildHourse {
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();
    public abstract House buildHouse();
}

public class CommonHouse extends BuildHourse {
    House house = new House();

    @Override
    public void buildBasic() {
        house.setBaise("地基5米");
        System.out.println("打地基5米");
    }

    @Override
    public void buildWalls() {
        house.setWall("墙3米");
        System.out.println("砌墙3米");
    }

    @Override
    public void roofed() {
        house.setRoofed("砖头头屋顶");
        System.out.println("盖砖头顶");
    }

    @Override
    public House buildHouse() {
        buildBasic();
        buildWalls();
        roofed();
        return house ;
    }
}

public class HighHouse extends BuildHourse {
    House house = new House();

    @Override
    public void buildBasic() {
        house.setBaise("地基20米");
        System.out.println("打地基20米");
    }

    @Override
    public void buildWalls() {
        house.setWall("墙30米");
        System.out.println("砌墙30米");
    }

    @Override
    public void roofed() {
        house.setRoofed("玻璃屋顶");
        System.out.println("盖玻璃顶");
    }

    @Override
    public House buildHouse() {
        buildBasic();
        buildWalls();
        roofed();
        return house ;
    }
}

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

上述代码建造了房子，但是建造房子的过程在房子的类中写死，这样一来如何建造房子的顺序重新编排，就需要单独写一个建房子的实现类了，比如就普通房子来说，如果不止建一个普通房子，一般是先地基，接着砌墙，然后做屋顶，如果在桥下建房子不需要屋顶，就要单独写写一个普通房子不带建屋顶的类，这就是没有实现产品和建造过程的解耦。所以使用建造者模式就是为了产品和建造者实现解耦！

举例：建房子
先画UML类图：

//产品->Product
public class House {
    private String baise;
    private String wall;
    private String roofed;

    public String getBaise() {
        return baise;
    }

    public void setBaise(String baise) {
        this.baise = baise;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
}

//抽象建造者
public abstract class HouseBuilder {
    protected House House=new House();

    //将建造的流程写好，抽象的方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();

    public House buildHouse(){
        return House;
    }
}

public class CommonHouse extends  HouseBuilder{

    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基5米");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙基10米");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子屋顶");
    }
}

public class HignBuilding extends  HouseBuilder{

    @Override
    public void buildBasic() {
        System.out.println("高楼打地基100米");
    }

    @Override
    public void buildWalls() {
        System.out.println("高楼砌墙基20米");
    }

    @Override
    public void roofed() {
        System.out.println("高楼的透明屋顶");
    }
}

//指挥者，这里去制定流程，返回产品
public class HouseDirector {
    HouseBuilder houseBuilder=null;

    //构造器传入houseBuilder
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //通过setter传入houseBuilder
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //建造流程交给指挥者
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

public class Client {
    public static void main(String[] args) {
        //建造普通房子
        CommonHouse commonHouse=new CommonHouse();
        HouseDirector houseDirector=new HouseDirector(commonHouse);
        House house=houseDirector.constructHouse();

        //建造大楼
        HignBuilding hignBuilding=new HignBuilding();
        HouseDirector highHouseDirector=new HouseDirector(hignBuilding);
        House highHouse=highHouseDirector.constructHouse();
    }
}

说明：增添了一个Director（指挥者），实现了产品和生产过程的解耦，如果需要改变建房子的过程直接增加一个Director就可以了，无需像未使用设计模式那样重新写一个复杂的产品来的方便！

根据先前学的设计模式七大原则思考是否违反（正好回顾一下掐前面的知识）：
1.单一职责原则：建房子，建高楼等每个类实现了单一职责
2.接口隔离原则：接口的最小化，没有用到接口
3.依赖倒转原则：面向接口开发，多用接口不用实体类，本代码用了抽象类去接实体对象，满足此要求
4.里式替换原则：没有重写父类的方法
5.开闭原则：我在建造新的类型的房子时，没有修改原来的类，实现对扩展开发，修改关闭。
6.迪米特法则：最少知道原则，没有将建造过程暴露给director，也咩有使用成员变量做到了最少知道的原则
7.组合服用原则：尽量不使用继承而用聚合和组合，此代码中没有多余的继承内容

源码中使用到这个设计模式的地方：jdk中的StirngBuilder
1.Appendable接口定义了多个append方法（抽象方法），即Appendable为抽象建造者，定义了抽象方法（如HouseBuilder）
2.AbstractStingBuilder实现了Appendable接口方法，这里的AbstractStingBuilder已经是建造者，只是不能实例化（如CommonHouse ，HighHouse）
3.StringBuilder即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由AbstractStingBuilder完成，而StingBuilder继承了AbstractStingBuilder（如HouseDirector）{个人思考：把建造的过程全都写入AbstractStingBuilder中，这样StringBuilder不就可以安安心心的做一个director了吗}