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

时间：2020-06-19 18:56:44 阅读：72 评论：0 收藏：0 [点我收藏+]

建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式。

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。

用户只需要给出指定对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）

　例子：

　　工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）

　　汽车购买者（用户）：你只需要说出你的需要型号（对象的类型和内容），然后直接购买就可以使用了（不需要知道汽车时怎末组装的（车轮，车门，发动机，方向盘等））　

技术分享图片

　抽象的建造者：不负责建房子，只是定以了一些接口和方法

package factory.builder.demo;
//抽象的建造者 ： 方法
public abstract class Builder {


    abstract void builderA();//地基
    abstract void builderB();//钢筋工程
    abstract void builderC();//铺电线
    abstract void builderD();//粉刷

    //完工：得到产品
    abstract Product getProduct();

}

　设计一个产品

package factory.builder.demo;
//产品： 房子
public class Product {

    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;


    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA=‘" + buildA + ‘\‘‘ +
                ", buildB=‘" + buildB + ‘\‘‘ +
                ", buildC=‘" + buildC + ‘\‘‘ +
                ", buildD=‘" + buildD + ‘\‘‘ +
                ‘}‘;
    }
}

具体的建造者

package factory.builder.demo;

//具体的建造者
public class Worker extends Builder {
            //工人负责创建产品
     private Product product;

    public Worker() { //这里时new一个Product
        product = new Product();
    }


    @Override
    void builderA() {
        product.setBuildA("地基");
        System.out.println("地基");

    }

    @Override
    void builderB() {
        product.setBuildB("钢筋工程");
        System.out.println("钢筋工程");
    }

    @Override
    void builderC() {
        product.setBuildC("铺电线");
        System.out.println("铺电线");

    }

    @Override
    void builderD() {
        product.setBuildD("粉刷");
        System.out.println("粉刷");

    }

    @Override
    Product getProduct() {
        return product;
    }
}

构建：指挥工程

package factory.builder.demo;
//指挥：核心。 负责指挥构建一个工程，工程如何构建，由它决定
public class Director {

    //指挥工人按照顺序建房子
    public Product build(Builder builder){//指挥抽象类创建产品
        builder.builderA();
        builder.builderB();
        builder.builderC();
        builder.builderD();

        return builder.getProduct();
    }
}

测试类

package factory.builder.demo;

public class Test {
    public static void main(String[] args) {
        //包工头 指挥
        Director director = new Director();
        //指挥具体的工人完成 产品
        Product build = director.build(new Worker());
        System.out.println(build.toString());
    }
}

不要指挥者的示例

抽象的建造者

package factory.builder.demo02;
//抽象的建造者
public  abstract class Builder {

    abstract  Builder builderA(String msg);//汉堡
    abstract  Builder builderB(String msg);//饮料
    abstract  Builder builderC(String msg);//薯条
    abstract  Builder builderD(String msg);//甜点


    abstract Product getProduct();

}

　　产品

package factory.builder.demo02;

//产品 ： 套餐
public class Product {

    private  String BuildA = "汉堡";
    private  String BuildB = "可乐";
    private  String BuildC = "薯条";
    private  String BuildD= "甜点";

    public String getBuildA() {
        return BuildA;
    }

    public void setBuildA(String buildA) {
        BuildA = buildA;
    }

    public String getBuildB() {
        return BuildB;
    }

    public void setBuildB(String buildB) {
        BuildB = buildB;
    }

    public String getBuildC() {
        return BuildC;
    }

    public void setBuildC(String buildC) {
        BuildC = buildC;
    }

    public String getBuildD() {
        return BuildD;
    }

    public void setBuildD(String buildD) {
        BuildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "BuildA=‘" + BuildA + ‘\‘‘ +
                ", BuildB=‘" + BuildB + ‘\‘‘ +
                ", BuildC=‘" + BuildC + ‘\‘‘ +
                ", BuildD=‘" + BuildD + ‘\‘‘ +
                ‘}‘;
    }
}

　　真实的构造者

package factory.builder.demo02;
//具体的建造者  完成产品的建造
public class Worker extends Builder {

    private Product product;

    public Worker() {
        product = new Product();
    }

    @Override
    Builder builderA(String msg) {
        product.setBuildA(msg);

        return this;
    }

    @Override
    Builder builderB(String msg) {
        product.setBuildB(msg);

        return this;
    }

    @Override
    Builder builderC(String msg) {
        product.setBuildC(msg);

        return this;
    }

    @Override
    Builder builderD(String msg) {
        product.setBuildD(msg);

        return this;
    }

    @Override
    Product getProduct() {
        return product;
    }
}

　　测试类

package factory.builder.demo02;

public class Test {
    public static void main(String[] args) {
        //服务员
        Worker worker = new Worker();

        //链式编程： 在原来的基础上，可以自由组合了，如果不组合，也有默认套餐

        Product product = worker.builderA("全家桶").builderB("雪碧")
                .getProduct();

        System.out.println(product.toString());
    }
}

技术分享图片