本文共 4326 字，大约阅读时间需要 14 分钟。

建造者模式（Builder Pattern）

建造者模式是一种创建型设计模式（ Creational Design Pattern ），适用于需要将一个复杂对象分解成多个简单对象并一步步构建的场景。这种模式的核心思想是将构造复杂对象与其表示相分离，使得同一个构建过程能够生成不同类型的对象。

定义

建造者模式通过一个 Builder 类 向步骤式地构建最终对象。该 Builder 类独立于其他字面意思对象，负责将各个部分组合在一起，形成最终的复杂对象。

核心思想

建造者模式的关键在于将 不变的部分与变化的部分分离开。这使得容易扩展和修改复杂对象的构建过程，而不需要修改已有的组成部分。这种模式尤其适用于以下情况：

• 有些部分的组件是固定的，而它们的组合却经常变化。
• 需要生成多种不同的对象，但它们具有共同的构建过程。

主要适用场景

建造者模式常见于如下的场景：

实现步骤

步骤 1：定义接口

首先，定义需要构建的物品和包装接口。

public interface Item {
    String getName();
    Packing getPacking();
    float getPrice();
}

public interface Packing {
    String getPack();
}

步骤 2：实现包装接口

创建实现 Packing 接口的类。

public class Wrapper implements Packing {
    @Override
    public String getPack() {
        return "Wrapper";
    }
}

public class Bottle implements Packing {
    @Override
    public String getPack() {
        return "Bottle";
    }
}

步骤 3：创建可扩展的抽象类

创建实现 Item 接口的抽象类，确保每个具体的物品都能提供自己的包装和价格。

public abstract class Burger implements Item {
    @Override
    public Packing getPacking() {
        return new Wrapper();
    }
    @Override
    public abstract float getPrice();
}

public abstract class ColdDrink implements Item {
    @Override
    public Packing getPacking() {
        return new Bottle();
    }
    @Override
    public abstract float getPrice();
}

步骤 4：创建具体实现类

扩展 Burger 和 ColdDrink 接下来，创建具体实现类。

public class VegBurger extends Burger {
    @Override
    public float getPrice() {
        return 25.0f;
    }
    @Override
    public String getName() {
        return "Veg Burger";
    }
}

public class ChickenBurger extends Burger {
    @Override
    public float getPrice() {
        return 50.5f;
    }
    @Override
    public String getName() {
        return "Chicken Burger";
    }
}

public class Coke extends ColdDrink {
    @Override
    public float getPrice() {
        return 30.0f;
    }
    @Override
    public String getName() {
        return "Coke";
    }
}

public class Pepsi extends ColdDrink {
    @Override
    public float getPrice() {
        return 35.0f;
    }
    @Override
    public String getName() {
        return "Pepsi";
    }
}

步骤 5：创建 Meal 类

定义 Meal 类，里面存储需要构建的物品和能够显示或计算总成本的功能。

public class Meal {
    private List
   
     items = new ArrayList<>();
    public void addItem(Item item) {
        items.add(item);
    }
    public float getCost() {
        float sum = 0.0f;
        for (Item item : items) {
            sum += item.getPrice();
        }
        return sum;
    }
    public void showItems() {
        for (Item item : items) {
            System.out.println("名称: " + item.getName());
            System.out.println("包装: " + item.getpacking().getPack());
            System.out.println("价格: " + item.getPrice());
            System.out.println("----------------");
        }
    }
}
   

步骤 6：创建 MealBuilder 类

MealBuilder 类的作用是将单独的物品构建为完整的 Meal 对象。

public class MealBuilder {
    public Meal prepareVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }
    public Meal prepareNonVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

步骤 7：演示示例

使用 MealBuilder 类构建不同套餐的 Meal。

public class BuilderPatternDemo {
    public static void main(String[] args) {
        MealBuilder mealBuilder = new MealBuilder();
        Meal vegMeal = mealBuilder.prepareVegMeal();
        System.out.println("素食套餐:");
        vegMeal.showItems();
        System.out.println("总价格: " + vegMeal.getCost());
        System.out.println("\n\n非素食套餐:");
        Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
        nonVegMeal.showItems();
        System.out.println("总价格: " + nonVegMeal.getCost());
    }
}

运行输出

运行上述程序将会输出：

素食套餐:
名称: Veg Burger
包装: Wrapper
价格: 25.0
名称: Coke
包装: Bottle
价格: 30.0
总价格: 55.0
非素食套餐:
名称: Chicken Burger
包装: Wrapper
价格: 50.5
名称: Pepsi
包装: Bottle
价格: 35.0
总价格: 85.5

优点分析

总结

建造者模式是一种非常有效的解决方案，适用于需要构建复杂对象但又希望保持代码结构清晰和可维护性的场景。通过将对象构建过程与对象表示分离开，可以独立地控制构建逻辑，提高代码的灵活性和扩展性。这也是为什么它被广泛应用于需要动态构建和组合不同组件的系统中。