尚硅谷设计模式学习(6)---[建造者模式(Builder Pattern)]

🚀🚀🚀尚硅谷传送门==>B站尚硅谷Java设计模式

❤❤❤感谢尚硅谷❤❤❤

🛴🛴🛴最近开始计划学习一下设计模式了,加油!!!

---

---

📢情景引入

建房的 过程为打桩、砌墙、封顶
各种房子的建造过程一样，但是需求不是相同的.

传统思路

建筑抽象类AbstractBuild

//盖房子的基类;
public abstract class AbstractBuild {
    //地基;
    public abstract void buildBasic();

    //砌墙'
    public abstract void buildWall();

    //盖顶;
    public abstract void roofed();

    //盖房子整体过程;
    public void build(){
        buildBasic();
        buildWall();
        roofed();
    }
}

高楼HighBuilding

//高楼
public class HighBuilding extends AbstractBuild{
    public void buildBasic() {
        System.out.println("高楼打地基");
    }

    public void buildWall() {
        System.out.println("高楼砌墙");
    }

    public void roofed() {
        System.out.println("高楼盖顶");
    }
}

模拟客户端Client

public class Client {
    public static void main(String[] args) {
        //盖高楼
        HighBuilding highBuilding = new HighBuilding();
        highBuilding.build();
        /*
        高楼打地基
        高楼砌墙
        高楼盖顶
         */
    }
}

需要注意的是,这种传统解法,将生产建造产品的过程和产品联系过于紧密;封装到了一块;耦合度过高.

🏡 建造者模式

又称为 生成器模式 ;

把完成的流程分解开来,抽象出来;

Product(产品) 具体产品对象
Builder (抽象建造者) 主要是定义建造产品的流程,抽象出来,一般用接口或抽象类表示
ConcreteBuilder（具体建造者) 继承抽象类/实现接口 , 构建部件;具体建造者都是独立的,符合开闭原则.
Director (指挥官) 构造使用Builder (抽象建造者)的对象;控制产品生产过程,隔离客户与产品.

客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象

对于盖房子案例的类图

产品House

//产品;
public class House {
    //地基
    private String basic;
    //墙;
    private String wall;
    //屋顶;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    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;
    }
}

抽象建造者HouseBuilder

//抽象的建造者;
public abstract class HouseBuilder {
    //将产品组合过来;
    //用protected;可以让同包下的类以及子类去访问;
    protected House house=new House();

    //地基;
    public abstract void buildBasic();
    //砌墙'
    public abstract void buildWall();
    //盖顶;
    public abstract void roofed();

    //盖房子;==>(房子盖好了)返回产品
    public  House buildHouse(){
        return house;
    }
}

具体建造,高楼HighBuilding

//高楼  ==> 具体建造者;
public class HighBuilding extends HouseBuilder{
    public void buildBasic() {
        System.out.println("高楼打地基");
    }

    public void buildWall() {
        System.out.println("高楼砌墙");
    }

    public void roofed() {
        System.out.println("高楼盖顶");
    }
}

具体建造,普通房CommonBuilder

//普通房子 ;  具体建造者;
public class CommonBuilder extends HouseBuilder{
    public void buildBasic() {
        System.out.println("普通房打地基");
    }

    public void buildWall() {
        System.out.println("普通房砌墙");
    }

    public void roofed() {
        System.out.println("普通房盖顶");
    }
}

指挥者 HouseDirector

//指挥者;
public class HouseDirector {
    private HouseBuilder houseBuilder=null;

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

    //set方法传入;
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //建造房子的流程;
    public House toBuild(){
        houseBuilder.buildBasic();
        houseBuilder.buildWall();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

模拟客户Client

//客户端;
public class Client {
    public static void main(String[] args) {
        //盖高楼;
        HighBuilding highBuilding=new HighBuilding();
        //指挥者参与;
        HouseDirector houseDirector=new HouseDirector(highBuilding);
        houseDirector.toBuild();
        /*
        高楼打地基
        高楼砌墙
        高楼盖顶
         */
        //盖房;
        CommonBuilder commonBuilder=new CommonBuilder();
        //重置;
        houseDirector.setHouseBuilder(commonBuilder);
        houseDirector.toBuild();
        /*
        普通房打地基
        普通房砌墙
        普通房盖顶
         */
    }
}

---

需要注意的是建造者模式下所使用的的产品 差不多是类似的,有共同点.

抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产

建造者模式则是按照指挥者分配 建造产品，主要是通过组装零配件而产生一个新产品

---

使用建造者模式的jdk案例

java.lang.StringBulider

继承了抽象类AbstractStringBuilder

StringBulider在重写方法时,又去调用了父类的方法.

StringBulider 作为指挥者,也是具体建造者.

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

但实际上的抽象建造者是Appendable接口,它定义了抽象方法.

---