设计模式之建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
 
建造者模式主要包含以下几个角色：
 
1. 产品（Product）：要创建的复杂对象。
2. 抽象建造者（Builder）：定义了创建产品各个部件的抽象方法。
3. 具体建造者（ConcreteBuilder）：实现抽象建造者的方法，负责构建产品的各个部分。
4. 指挥者（Director）：负责按照一定的顺序调用建造者的方法来构建产品。
 
建造者模式的优点包括：
 
1. 良好的封装性，构建过程和产品的表示分离。
2. 建造者之间相互独立，便于扩展和维护。
3. 控制产品的创建过程，使得创建过程更加清晰和可控。
 
以下是一个用 Java 实现的建造者模式示例：
 
// 产品类
class Product {
    private String partA;
    private String partB;
    private String partC;

    // 提供获取各个部分的方法
    public String getPartA() {
        return partA;
    }

    public String getPartB() {
        return partB;
    }

    public String getPartC() {
        return partC;
    }

    // 为各个部分设置值的方法
    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }
}

// 抽象建造者
abstract class Builder {
    protected Product product = new Product();

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    public Product getProduct() {
        return product;
    }
}

// 具体建造者 1
class ConcreteBuilder1 extends Builder {
    @Override
    public void buildPartA() {
        product.setPartA("Part A of ConcreteBuilder1");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part B of ConcreteBuilder1");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part C of ConcreteBuilder1");
    }
}

// 具体建造者 2
class ConcreteBuilder2 extends Builder {
    @Override
    public void buildPartA() {
        product.setPartA("Part A of ConcreteBuilder2");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part B of ConcreteBuilder2");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part C of ConcreteBuilder2");
    }
}

// 指挥者
class Director {
    public void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

public class BuilderPatternExample {
    public static void main(String[] args) {
        Director director = new Director();

        Builder builder1 = new ConcreteBuilder1();
        director.construct(builder1);
        Product product1 = builder1.getProduct();
        System.out.println("Product 1: ");
        System.out.println(product1.getPartA());
        System.out.println(product1.getPartB());
        System.out.println(product1.getPartC());

        Builder builder2 = new ConcreteBuilder2();
        director.construct(builder2);
        Product product2 = builder2.getProduct();
        System.out.println("Product 2: ");
        System.out.println(product2.getPartA());
        System.out.println(product2.getPartB());
        System.out.println(product2.getPartC());
    }
}
 
 
在上述示例中，通过不同的具体建造者和指挥者的协作，可以创建出具有不同部件组合的产品对象。