最通俗易懂的设计模式之建造者模式

最新推荐文章于 2024-10-06 20:16:20 发布

七月的渡口

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量140

点赞数

分类专栏：设计模式文章标签： java 设计模式

本文链接：https://blog.csdn.net/sgy86/article/details/108923760

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了建造者模式的概念，通过建筑大楼和快餐制作的类比，展示了如何使用抽象Builder和具体Worker类来构建产品。指挥者Director负责控制建造顺序，而Builder提供了构建产品的步骤。此外，还提出了对建造者模式和抽象工厂模式的比较，并通过快餐套餐的例子展示了更灵活的Builder实现方式。

摘要由CSDN通过智能技术生成

认识建造者模式，首先得清楚建造者模式使用涉及的角色

首先定义抽象的Builder

public abstract class Builder {
    abstract void builder1();//地基
    abstract void builder2();//钢筋
    abstract void builder3();//浦电线
    abstract void builder4();//粉刷


    abstract Product getProduct();
}

再定义所builder 中需要构造的产品

//产品
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 + '\'' +
                '}';
    }
}
抽象的builder类就相当与建造大楼的图纸，具体的实现类需要有worker进行实现

//具体建造者
public class Worker extends Builder {

    private  Product product;

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



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

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

    @Override
    void builder3() {
        product.setBuildC("浦电线");
        System.out.println("浦电线");
    }

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

    @Override
    Product getProduct() {
        return product;
    }
}
最后有指挥者可以控制建造大楼的顺序

//指挥创建

public class Director {

    public Product build(Builder builder){
        builder.builder1();
        builder.builder3();
        builder.builder2();
        builder.builder4();
       return builder.getProduct();
    }
}
测试类

public class Test {

//    1.与抽象工厂模式想，建造者模式返回一个组装好的完整的产品，而抽象工厂模式返回一系列相关产品，这些产品位于不容产品的等级结构。构成产品族。
//    2.抽象工厂模式中，客户端先实例工厂类，然后调用工厂方法获取所需的对象，而在建造者模式中，客户段可以以不直接调用建造者相关方法，而是直接通过指挥者类来指导如何生成对象
//    3.如果将抽象工程模式堪称是汽车配件生产工厂，生产一个产品组的产品。那么建造者模式就是译者汽车的组装工厂，通过对零部件的组装可以返回完整车辆
    public static void main(String[] args) {
        //指挥
        Director director = new Director();
        //指挥工人完成产品
        Product build = director.build(new Worker());
        System.out.println(build.toString());
    }
}

上述例子有些许不方便的地方，例如如果想构造大楼必须新建一个指挥类，下面可以使用静态方法进行改造

下面以快餐店套餐的方式模拟具体的方式

public abstract class Builder {
    abstract Builder builder1(String msg);//汉堡
    abstract Builder builder2(String msg);//可乐
    abstract Builder builder3(String msg);//薯条
    abstract Builder builder4(String msg);//甜点


    abstract Product getProduct();
}

//产品
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 + '\'' +
                '}';
    }
}

public class Worker extends Builder {

    private  Product product;

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

    @Override
    Builder builder1(String msg) {
        product.setBuildA(msg);
        return this;
    }

    @Override
    Builder builder2(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder builder3(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder builder4(String msg) {
        product.setBuildD(msg);
        return this;
    }

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