建造者模式结构类图：建房子

 要求：

画出请用建造者模式设计该需求的模式结构类图，并指出各类承担的角色。（以下是某房屋建筑的需求描述。建房子的过程都依次为：

打地基（buildBase）——>，砌墙（buildWall）——>，封顶 （buildRoof）;

建造的房子有多样，如普通房子（CommonHouse），高楼(HighBuilding)，别墅（Villa）等;

     各种房子的建造过程虽然一样，但是具体要求各不相同，即不同的房子有不同的属性， 如地基（base），墙（wall），屋顶（roof）等属性各不相同）。

什么是建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，用于构建一个复杂对象，同时允许用户只通过指定复杂对象的类型和内容就能构建它们，不必知道内部的构建细节。建造者模式可以将对象的构建过程和表示分离，使得同样的构建过程可以创建出不同表示的对象。 建造者模式原理类图如下：

通常包含的角色

建造者模式通常包含以下几个角色：

1. Builder（抽象建造者）：定义创建产品的接口，提供创建产品的方法。

2. ConcreteBuilder（具体建造者）：实现抽象建造者接口，具体实现创建产品的方法，并且构造最终的产品。

3. Director（指挥者）：负责协调构建过程，它接受一个建造者对象，并使用该对象的构建方法来创建产品。

4. Product（产品）：表示被构建的复杂对象，包含多个属性，这些属性由建造者来设置。

主要优点

建造者模式的主要优点是：

• 封装性：隐藏了对象的构建过程，用户不需要知道对象是如何构建的。
• 灵活性：指挥者与具体建造者解耦，可以通过改变具体建造者来创建不同的产品。
• 扩展性：可以通过增加新的具体建造者来扩展产品，而不需要修改现有代码。

适用场景

建造者模式适用于以下场景：

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
• 当构造过程包含多个步骤，而这些步骤具有相同的顺序，但是具体的实现可能会变化时。

 建造者模式实例

角色说明

1. HouseBuilder（建造者）

定义构造房子的步骤的接口，包括“buildBase()”、“buildWall()”、“buildRoof()”。

具体实现：定义一个抽象的“Builder”接口，包含构造房子的步骤方法“buildBase()”、“buildWall()”和“buildRoof()”以及返回建造完成产品的方法“getResult()”。

2. ConcreteBuilder（具体建造者）

实现“Builder”接口，构造和装配各个部分的具体实现，如“CommonHouse”、“HighBuilding”、“VillaHouse”。

具体实现：实现“Builder”接口，具体的“CommonHouse”、“HighBuilding”和“VillaHouse” 负责构建具体的房子实例，并实现其建造细节。

3. Product（产品）

表示最终要建造的房子对象，如“House”，包含属性 ”base”、“wall”、“roof”。

具体实现：定义“House”类，表示最终建造的房子对象，包含地基、墙和屋顶的属性及其设置和获取方法。

4. HouseDirector（指挥者）

负责安排具体的建造过程，使用“Builder”的对象来完成整个建造过程。

具体实现：定义“Director”类，它持有一个“HouseBuilder”对象，并负责控制房子建造的过程。其方法“construct()”调用“HouseBuilder”的建造步骤方法来完成建造。

画出建造者模式结构类图

 

Java代码实现

// 产品类：房子
class House {
    private String base;
    private String wall;
    private String roof;

    // 省略 getter 和 setter 方法
    public String getBase() { return base; }
    public void setBase(String base) { this.base = base; }
    public String getWall() { return wall; }
    public void setWall(String wall) { this.wall = wall; }
    public String getRoof() { return roof; }
    public void setRoof(String roof) { this.roof = roof; }

    // 用于展示房子的详细信息
    public void showHouseInfo() {
        System.out.println("House Info: Base - " + base + ", Wall - " + wall + ", Roof - " + roof);
    }
}

// 抽象建造者
interface HouseBuilder {
    void buildBase();
    void buildWall();
    void buildRoof();
    House getResult();
}

// 具体建造者：普通房子建造者
class CommonHouseBuilder implements HouseBuilder {
    private House house;

    public CommonHouseBuilder() {
        this.house = new House();
    }

    @Override
    public void buildBase() {
        house.setBase("Common Base");
    }

    @Override
    public void buildWall() {
        house.setWall("Common Wall");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Common Roof");
    }

    @Override
    public House getResult() {
        return house;
    }
}

// 具体建造者：高楼建造者
class HighBuildingBuilder implements HouseBuilder {
    private House house;

    public HighBuildingBuilder() {
        this.house = new House();
    }

    @Override
    public void buildBase() {
        house.setBase("High Building Base");
    }

    @Override
    public void buildWall() {
        house.setWall("High Building Wall");
    }

    @Override
    public void buildRoof() {
        house.setRoof("High Building Roof");
    }

    @Override
    public House getResult() {
        return house;
    }
}

// 指挥者
class HouseDirector {
    private HouseBuilder builder;

    public HouseDirector(HouseBuilder builder) {
        this.builder = builder;
    }

    public House construct() {
        builder.buildBase();
        builder.buildWall();
        builder.buildRoof();
        return builder.getResult();
    }
}

// 客户端代码
public class BuilderPatternDemo {
    public static void main(String[] args) {
        HouseDirector director = new HouseDirector(new CommonHouseBuilder());
        House house = director.construct();
        house.showHouseInfo();

        // 如果需要建造高楼，可以这样做：
        director = new HouseDirector(new HighBuildingBuilder());
        house = director.construct();
        house.showHouseInfo();
    }
}