9.建造者模式

发布时间:2024年01月09日


一、介绍

建造者模式旨在将一个复杂对象的构建过程和其表示分离,以便同样的构建过程可以创建不同的表示。这种模式适用于构建对象的算法(构建过程)应该独立于对象的组成部分以及它们的装配方式的情景。

建造者模式通常包含以下角色:

  1. 产品(Product): 表示被构建的复杂对象。在建造者模式中,产品是由多个部件组成的。

  2. 抽象建造者(Builder): 声明了创建产品各个部件的抽象接口。通常包括创建和装配部件的方法。

  3. 具体建造者(Concrete Builder): 实现抽象建造者接口,负责具体部件的创建和装配。每个具体建造者都定义了自己的方式来构建产品。

  4. 指导者(Director): 负责使用建造者接口来构建产品对象。通常包含一个构建方法,该方法定义了构建产品的顺序。

二、代码

结构图

在这里插入图片描述

代码

/**
 * 产品类,由多个部件构成
 */
public class Product {

    private List<String> parts = new ArrayList<>();

    public void add(String part) {
        parts.add(part);
    }

    public void show(){
        System.out.println("产品部件 --->");
        for (String part : parts) {
            System.out.print(part+" ");
        }
    }
}
/**
 * 抽象建造者类,确定产品由两个部件构成,并声明一个得到产品的方法
 */
abstract class Builder{
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}
class Builder1 extends Builder {

    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.add("部件a");
    }

    @Override
    public void buildPartB() {
        product.add("部件b");
    }

    @Override
    public Product getResult() {
        return product;
    }
}
class Builder2 extends Builder {

    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.add("部件x");
    }

    @Override
    public void buildPartB() {
        product.add("部件y");
    }

    @Override
    public Product getResult() {
        return product;
    }
}
/**
 * 指挥者类,用来指挥构建过程
 */
class Director {
    public Product Construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        return builder.getResult();
    }
}
public static void main(String[] args) {
    Director director = new Director();
    Builder1 builder1 = new Builder1();
    Builder2 builder2 = new Builder2();
    
    Product result1 = director.Construct(builder1);
    result1.show();

    Product result2 = director.Construct(builder2);
    result2.show();
}

三、实际使用

场景

假设我们要创建一个汽车对象,汽车有多个可选的配置,包括引擎类型、车身颜色、轮胎类型等。我们将使用建造者模式来实现汽车对象的配置灵活性。

代码

// 产品类:汽车
class Car {
    private String engineType;
    private String bodyColor;
    private String tireType;

    // 构造方法私有化,只能通过建造者来构建对象
    private Car() {
    }

    public String getEngineType() {
        return engineType;
    }

    public String getBodyColor() {
        return bodyColor;
    }

    public String getTireType() {
        return tireType;
    }

    // 静态内部类作为具体建造者
    public static class Builder {
        private Car car;

        public Builder() {
            this.car = new Car();
        }

        public Builder setEngineType(String engineType) {
            car.engineType = engineType;
            return this;
        }

        public Builder setBodyColor(String bodyColor) {
            car.bodyColor = bodyColor;
            return this;
        }

        public Builder setTireType(String tireType) {
            car.tireType = tireType;
            return this;
        }

        // 构建汽车对象
        public Car build() {
            return car;
        }
    }
}

// 客户端
public class BuilderPatternFlexibilityExample {
    public static void main(String[] args) {
        // 使用建造者模式构建汽车对象,并灵活配置
        Car car1 = new Car.Builder()
                .setEngineType("V8")
                .setBodyColor("Red")
                .setTireType("Summer")
                .build();

        Car car2 = new Car.Builder()
                .setEngineType("Hybrid")
                .setBodyColor("Blue")
                .build();

        // 输出构建好的汽车对象
        System.out.println("Car 1 - Engine Type: " + car1.getEngineType() +
                ", Body Color: " + car1.getBodyColor() +
                ", Tire Type: " + car1.getTireType());

        System.out.println("Car 2 - Engine Type: " + car2.getEngineType() +
                ", Body Color: " + car2.getBodyColor() +
                ", Tire Type: " + car2.getTireType());
    }
}

上面的例子中,Car 是产品类,Car.Builder 是具体建造者。通过具体建造者,我们可以设置汽车的各个可选配置,最后通过 build 方法得到一个完整的汽车对象。客户端可以根据实际需求来选择设置不同的配置,实现了对象配置的灵活性。这种方式可以避免创建多个构造函数以应对各种配置组合的情况,使得代码更加简洁和可维护。

总结

上面的代码中,我们通过不同的具体建造者,同一个指挥者,获得了不一样的产品。在我们平时的情况中,以下的场景可以用到建造者模式

  1. 创建复杂对象: 当一个对象的构建过程比较复杂,涉及多个步骤、部件组合或配置选项时,建造者模式可以将构建过程与最终表示分离,使得代码更清晰、可维护。

  2. 对象的配置灵活性: 当需要创建的对象具有多个配置选项,而客户端希望能够以不同的方式组装对象时,建造者模式可以提供更灵活的配置选择,而无需创建大量的构造函数。

  3. 避免构造器参数过多: 当一个对象的构造函数参数过多,而且可能存在多个可选参数时,使用建造者模式可以避免创建过多的构造函数,使得代码更加清晰。

文章来源:https://blog.csdn.net/csdn15917204572/article/details/135395306
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。