GOF23之建造者模式

建造者模式

什么是G0F设计模式:https://blog.csdn.net/weixin_51250404/article/details/119777525?spm=1001.2014.3001.5501
工厂模式:https://blog.csdn.net/weixin_51250404/article/details/119852808?spm=1001.2014.3001.5501
单例模式:https://blog.csdn.net/weixin_51250404/article/details/119843201?spm=1001.2014.3001.5501

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、建造者模式定义

• 建造者也属于创建型模式,它提供一种创建对象的最佳方式
• 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

二、主要作用

• 在用户不知道对象的建造过程好细节的情况下就可以直接创复杂对象
• 用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂的对象(把内部的建造过程和细节隐藏起来)

三、例子：

• 工厂(建造者模式）：负责制造汽车(组装过程和细节在工厂内)
• 汽车购买者(用户)： 你只需要说出你需要的–>型号(对象的类型和内容)，然后直接购买就可以使用了(并不需要了解车是怎组装的)
  通过静态内部类方式实现零件无序装配构造，这种方式更加灵活，更符合定义，内部具有复杂对象的默认实现，实现可以根据用户的需求自定义更改内容，并且无需更给具体的构造方法，就可以生产不同复杂产品
• 比如 麦当劳的套餐，服务员（具体构造者）可以随意搭配任意集中产品（零件）组成一款套餐（产品），然后出售给客户，少了指挥者，或者说是用户也可以是指挥者

1.抽象工厂

代码如下（示例）：

package build.demo2;

public abstract class Build {
     abstract Build buildA(String mes);//汉堡
     abstract Build buildB(String mes);//薯条1
     abstract Build buildC(String mes);//可乐
     abstract Build buildD(String mes);//炸鸡

    abstract Product getBuilder();
}

2.产品

代码如下（示例）：

package build.demo2;
//产品:套餐
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 + '\'' +
                '}';
    }
}

3. 具体的建造者

package build.demo2;
//具体的建造者
public class Work extends Build{
    private Product product;

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

    @Override
    Build buildA(String mes) {
        product.setBuildA(mes);
        return this;
    }

    @Override
    Build buildB(String mes) {
        product.setBuildB(mes);
        return this;
    }

    @Override
    Build buildC(String mes) {
        product.setBuildC(mes);
        return this;
    }

    @Override
    Build buildD(String mes) {
        product.setBuildD(mes);
        return this;
    }

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

4.用户

package build.demo2;

//用户
public class Test {
    public static void main(String[] args) {
    //服务员
        Work work=new Work();
        //链式编程 在原来的基础上 可以自由组合了 如果不组合就有默认的套餐
        Product p1=work.buildA("全家桶").buildB("可乐").
                getBuilder();
        Product p=work.getBuilder();
        System.out.println(p1.toString());
    }
}

四、优缺点

优点：

• 将产品的建造和表示分离,实现了解耦,使用建造者模式可以使客户端不必知道产品内部组件的细节.
• 将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰
• 具体的建造者模类之间是相互独立存在的,这有利于系统的扩展,增加新的具体建造者无需修改原有类库的代码,符合"开闭原则"

缺点：

• 建造者模式所创建的产品一般都是具有较多共同点,其组成部分相似,如果产品之间的差异性较大,则不适合使用建造者模式,因此范围受一定的影响
• 如果产品内部化复杂,可能会导致要定义很多具体建造者类来实现这种变化,导致系统变化得很庞大

五、应用场景

• 需要生产的产品对象的复杂的内部结构,这些对象具有共同性
• 隔离复杂的对象的创建和使用,并使得相同的创建过程可以创建不同的产品
• 适合于一个具有较多的零件(属性)的产品(对象)的创建过程

建造者模式与抽象工厂相比

提示：抽象工厂是可以去查看上一篇博客：https://blog.csdn.net/weixin_51250404/article/details/119852808?spm=1001.2014.3001.5501

• 与抽象工厂相比,建造者模式返回一个组装好的完整的产品,而抽象工厂返回一系列相关的产品,这些产品位于不同的产品等级结构,构成一个产品族
• 在抽象工厂模式中,客户端实例化工厂类,然后调用工厂方法获取所需要的产品对象,而在建造者模式中,客户端可以不直接调用建造者的相关方法,而是通过指挥者类来知道如何生成对象,包括对象的组装过程和建造步骤,它侧重于一步步构造一个复杂对象,返回一个完整的对象
• 如果将抽象工厂比作是汽车配件去生产工厂,生产一个产品的品族,那么建造者模式就是一个汽车组装工厂,通过对部件的组装可以返回一辆完整的汽车!