当前位置：首页 > article >正文

04 设计模式-创造型模式-建造者模式

article 2024/12/28 11:30:15

建造者模式是一种创建型设计模式，它允许你创建复杂对象的步骤与表示方式相分离。

建造者模式是一种创建型设计模式，它的主要目的是将一个复杂对象的构建过程与其表示相分离，从而可以创建具有不同表示形式的对象。

设计模式，最近持续更新中，如需要请关注

如果你觉得我分享的内容或者我的努力对你有帮助，或者你只是想表达对我的支持和鼓励，请考虑给我点赞、评论、收藏。您的鼓励是我前进的动力，让我感到非常感激。

文章目录

1 概要
2 实现
3 Demo代码
4 建造者模式和工厂模式的区别

1 概要

意图
将一个复杂的构建过程与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决
在软件系统中，一个复杂对象的创建通常由多个部分组成，这些部分的组合经常变化，但组合的算法相对稳定。

何时使用
当一些基本部件不变，而其组合经常变化时。

如何解决
将变与不变的部分分离开。

关键代码

建造者： 创建并提供实例。
导演： 管理建造出来的实例的依赖关系和控制构建过程。

应用实例
去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出不同的"套餐"。
Java 中的 StringBuilder。

优点

分离构建过程和表示，使得构建过程更加灵活，可以构建不同的表示。
可以更好地控制构建过程，隐藏具体构建细节。
代码复用性高，可以在不同的构建过程中重复使用相同的建造者。

缺点

如果产品的属性较少，建造者模式可能会导致代码冗余。
增加了系统的类和对象数量。

使用场景

需要生成的对象具有复杂的内部结构。
需要生成的对象内部属性相互依赖。

注意事项
与工厂模式的区别是：建造者模式更加关注于零件装配的顺序。

结构
建造者模式包含以下几个主要角色：

产品（Product）： 要构建的复杂对象。产品类通常包含多个部分或属性。
抽象建造者（Builder）： 定义了构建产品的抽象接口，包括构建产品的各个部分的方法。
具体建造者（Concrete Builder）： 实现抽象建造者接口，具体确定如何构建产品的各个部分，并负责返回最终构建的产品。
指导者（Director）： 负责调用建造者的方法来构建产品，指导者并不了解具体的构建过程，只关心产品的构建顺序和方式。

2 实现

我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。

我们将创建一个表示食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类，以及一个表示食物包装的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。

然后我们创建一个 Meal 类，带有 Item 的 ArrayList 和一个通过结合 Item 来创建不同类型的 Meal 对象的 MealBuilder。BuilderPatternDemo 类使用 MealBuilder 来创建一个 Meal。

在这里插入图片描述

3 Demo代码

在这里插入图片描述
1 创建一个表示食物条目和食物包装的接口。item(name,packing,price), Packing

/**
 * 商品项目
 */
public interface Item {
    /**
     * 商品名称【实现类需要重写】
     *
     * @return
     */
    public String name();

    /**
     * 商品包装【隐藏内部细节，实现类需要重写】
     *
     * @return
     */
    public Packing packing();

    /**
     * 商品价格【实现类需要重写】
     *
     * @return
     */
    public float price();
}

public interface Packing {
    public String pack();
}

2 创建实现 Packing 接口的实体类。 Burger、ColdDrink (这一层指定了packing)

/**
 * 商品包装接口实现类 - 瓶装
 */
public class Bottle implements Packing {
    @Override
    public String pack() {
        return "Bottle";
    }
}

/**
 * 商品包装接口实现类 - 纸包装
 */
public class Wrapper implements Packing {
    @Override
    public String pack() {
        return "Wrapper";
    }
}

3 创建实现 Item 接口的抽象类，该类提供了默认的功能。

/**
 * 汉堡抽象类 【实现了Item接口，重写了packing方法，price方法继续抽象】
 */
public  abstract class Burger implements Item {
    @Override
    public Packing packing() {
        return new Wrapper();
    }
}

/**
 * 冷饮抽象类 【实现了Item接口，重写了packing方法，price方法继续抽象】
 */
public abstract class ColdDrink implements Item {

    @Override
    public Packing packing() {
        return new Bottle();
    }
    
}

4 创建扩展了 Burger 和 ColdDrink 的实体类。（VegBurger/ChickenBurger、Coke/Pepsi (这一层指定了name和price)）

/**
 * 素食汉堡 【继承了抽象Burger类，到这一层具体知道了商品的价格和名称】
 */
public class VegBurger extends Burger {
    @Override
    public float price() {
        return 25.0f;
    }

    @Override
    public String name() {
        return "Veg Burger";
    }
}

 * 鸡肉汉堡 【继承了抽象Burger类，到这一层具体指导了商品的价格和名称】
 */
public class ChickenBurger extends Burger {

    @Override
    public float price() {
        return 50.5f;
    }

    @Override
    public String name() {
        return "Chicken Burger";
    }
}

/**
 * 可口可乐【继承了抽象ColdDrink类，到这一层具体指导了商品的价格和名称】
 */
public class Coke extends ColdDrink {
    @Override
    public float price() {
        return 30.0f;
    }

    @Override
    public String name() {
        return "Coke";
    }
}

/**
 * 百事可乐【继承了抽象ColdDrink类，到这一层具体指导了商品的价格和名称】
 */
public class Pepsi extends ColdDrink {

    @Override
    public float price() {
        return 35.0f;
    }

    @Override
    public String name() {
        return "Pepsi";
    }
}

5 创建一个 Meal 类，带有上面定义的 Item 对象。

/**
 * 套餐 【每个套餐包含了多个商品项目】
 */
public class Meal {
    /**
     * 商品列表
     */
    private List<Item> items = new ArrayList<Item>();

    /**
     * 添加商品
     *
     * @param item
     */
    public void addItem(Item item) {
        items.add(item);
    }

    /**
     * 获取价格
     *
     * @return
     */
    public float getCost() {
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }

    /**
     * 打印账单
     */
    public void showItems() {
        for (Item item : items) {
            System.out.print("Item : " + item.name());
            System.out.print(", Packing : " + item.packing().pack());
            System.out.println(", Price : " + item.price());
        }
    }
}

6 创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。

/**
 * 套餐建造者类【可以随意组合不同的商品】
 */
public class MealBuilder {
    /**
     * 套餐1： 素食套餐【素食汉堡 + 可口可乐】
     *
     * @return
     */
    public Meal prepareVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    /**
     * 套餐2： 非素食套餐【鸡肉汉堡 + 百事可乐】
     *
     * @return
     */
    public Meal prepareNonVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }

    /**
     * 套餐3： 全家桶掏槽【2个鸡肉汉堡 + 2个素食汉堡 + 2瓶可口可乐 + 2瓶百事可乐】
     *
     * @return
     */
    public Meal prepareFamilyBucket() {
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        meal.addItem(new Pepsi());
        meal.addItem(new ChickenBurger());
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        meal.addItem(new Pepsi());
        return meal;
    }
}

7 BuiderPatternDemo 使用 MealBuilder 来演示建造者模式（Builder Pattern）。

/*
建造者：
    MealBuilder: 对商品进行包装【可以随意组合商品项目】
    Meal: 套餐，【隐藏各个商品的细节(制造的过程)，展示详情列表和价格】

导演：
    item(name,packing,price) <- Burger、ColdDrink (这一层指定了packing) <- VegBurger/ChickenBurger、Coke/Pepsi (这一层指定了name和price)
 */

/**
 * 总结：用来将子项，按照不同的需求组装在一起，生成一个大的包装类【套餐1、套餐2、套餐3】
 */
public class BuilderPatternDemo {
    public static void main(String[] args) {
        MealBuilder mealBuilder = new MealBuilder();

        // 套餐1： 素食套餐【素食汉堡 + 可口可乐】
        Meal vegMeal = mealBuilder.prepareVegMeal();
        System.out.println("Veg Meal");
        vegMeal.showItems();
        System.out.println("Total Cost: " + vegMeal.getCost());

        // 套餐2： 非素食套餐【鸡肉汉堡 + 百事可乐】
        Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
        System.out.println("\n\nNon-Veg Meal");
        nonVegMeal.showItems();
        System.out.println("Total Cost: " + nonVegMeal.getCost());

        // 套餐3： 全家桶掏槽【2个鸡肉汉堡 + 2个素食汉堡 + 2瓶可口可乐 + 2瓶百事可乐】
        Meal familyBucket = mealBuilder.prepareFamilyBucket();
        System.out.println("\n\nfamily-bucket Meal");
        familyBucket.showItems();
        System.out.println("Total Cost: " + familyBucket.getCost());
    }
}

8 执行结果
在这里插入图片描述

4 建造者模式和工厂模式的区别

建造者模式是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式与工厂模式的区别:
1. 工厂模式一般都是创建一个产品，注重的是把这个产品创建出来就行，只要创建出来，不关心这个产品的组成部分。从代码上看，工厂模式就是一个方法，用这个方法就能生产出产品。
2. 建造者模式也是创建一个产品，但是不仅要把这个产品创建出来，还要关系这个产品的组成细节，组成过程。
3. 从代码上看，建造者模式在建造产品时，这个产品有很多方法，建造者模式会根据这些相同方法但是不同执行顺序建造出不同组成细节的产品。
4. 总结，工厂模式关心整体，建造者模式关心细节。

查看全文

http://www.kler.cn/a/354077.html