设计模式之建造者模式

最新推荐文章于 2023-07-22 20:57:42 发布

Leo木

最新推荐文章于 2023-07-22 20:57:42 发布

阅读量109

点赞数

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

本文链接：https://blog.csdn.net/weixin_40388441/article/details/109614479

版权

设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

1、定义

建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2、形式

建造者模式通用类图如下所示：

在这里插入图片描述
类图中各类含义为：

Product为产品类，通常是实现了模板方法模式的类。
Builder为抽象建造者，由其子类去实现实际产品的组建。
ConcreteBuilder为具体建造者，实现抽象类定义的所有方法，并返回一个组建好的对象。
Director为导演类，负责安排已有模块的顺序，然后告诉Builder开始建造。

通用源码如下：

Product

public class Product {
    public void doSomething(){
        //业务处理
    }
}

Builder

public abstract class Builder {
    //设置产品的不同部分，以获得不同的产品
    public abstract void setPart();
    //组建一个产品
    public abstract Product buildProduct();
}

ConcreteBuilder

public class ConcreteBuilder extends Builder {
    private Product product = new Product();
    public void setPart() {
        /*
        * 产品类内的逻辑处理
        * */
    }

    public Product buildProduct() {
        return product;
    }
}

Director

public class Director {
    private Builder builder = new ConcreteBuilder();
    //构建不同的产品
    public Product getAProduct(){
        /*
        *逻辑代码
        * */
        builder.setPart();
        /*
        * 设置不同的零件生成不同的产品
        * */
        return  builder.buildProduct();
    }
}

示例：

抽象产品类采用模板方法模式定义产品对象，抽象产品构造者抽象出构建逻辑，由各个子类具体实现，导演类定义不同顺序的零件装配方式以生产不同的产品，场景类负责调用导演类获得产品对象。
在这里插入图片描述

AbstractProduct

public abstract class AbstractProduct {
    private ArrayList<String> sequence = new ArrayList<String>();
    //零件一
    protected abstract void partOne();
    //零件二
    protected abstract void partTwo();
    //零件三
    protected abstract void partThree();
    //组装过程
    final public void getStructure(){
        for (int i = 0; i < sequence.size(); i++) {
            String partName = sequence.get(i);
            if(partName == "partOne"){
                this.partOne();
            }else if(partName == "partTwo"){
                this.partTwo();
            }else if(partName == "partThree"){
                this.partThree();
            }
        }
    }
    final public void setPart(ArrayList sequence){
        this.sequence = sequence;
    }
}

ProductA

public class ProductA extends AbstractProduct{
    protected void partOne() {
        System.out.println("A's partOne");
    }

    protected void partTwo() {
        System.out.println("A's partTwo");
    }

    protected void partThree() {
        System.out.println("A's partThree");
    }
}

ProductB

public class ProductB extends AbstractProduct{
    protected void partOne() {
        System.out.println("B's partOne");
    }

    protected void partTwo() {
        System.out.println("B's partTwo");
    }

    protected void partThree() {
        System.out.println("B's partThree");
    }
}

AbstractProductBuilder

public abstract class AbstractProductBuilder {
    public abstract void setSequence(ArrayList<String> sequence);
    public abstract AbstractProduct getProduct();
}

ProductABuilder

public class ProductABuilder extends AbstractProductBuilder{
    private ProductA productA = new ProductA();

    public AbstractProduct getProduct() {
        return this.productA;
    }

    public void setSequence(ArrayList<String> sequence) {
        this.productA.setPart(sequence);
    }
}

ProductBBuilder

public class ProductBBuilder extends AbstractProductBuilder{
    private ProductB productB = new ProductB();

    public AbstractProduct getProduct() {
        return this.productB;
    }

    public void setSequence(ArrayList<String> sequence) {
        this.productB.setPart(sequence);
    }
}

Director

public class Director {
    private ArrayList<String> sequence = new ArrayList();
    private ProductABuilder productABuilder = new ProductABuilder();
    private ProductBBuilder productBBuilder = new ProductBBuilder();

    //获得型号为1的产品A
    public ProductA getProductA1Model(){
        this.sequence.clear();
        this.sequence.add("partOne");
        this.sequence.add("partTwo");
        this.sequence.add("partThree");
        this.productABuilder.setSequence(this.sequence);
        return (ProductA)this.productABuilder.getProduct();
    }

    //获得型号为2的产品A
    public ProductA getProductA2Model(){
        this.sequence.clear();
        this.sequence.add("partThree");
        this.sequence.add("partOne");
        this.sequence.add("partTwo");
        this.productABuilder.setSequence(this.sequence);
        return (ProductA)this.productABuilder.getProduct();
    }
    //获得型号为3的产品B
    public ProductB getProductB3Model(){
        this.sequence.clear();
        this.sequence.add("partTwo");
        this.sequence.add("partThree");
        this.sequence.add("partOne");
        this.productBBuilder.setSequence(this.sequence);
        return (ProductB)this.productBBuilder.getProduct();
    }
}

Client

public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        System.out.println("型号为1的A产品结构组成为：");
        director.getProductA1Model().getStructure();
        System.out.println("型号为2的A产品结构组成为：");
        director.getProductA2Model().getStructure();
        System.out.println("型号为3的B产品结构组成为：");
        director.getProductB3Model().getStructure();
    }
}