【详解】JAVA设计模式建造者模式（Builder）

2025-07-24 06:22:55

【详解】JAVA设计模式建造者模式（Builder） JAVA设计模式建造者模式（Builder）在面向对象编程中，设计模式是一种在特定情况下解决软件设计问题的通用可重用解决方案。设计模式并不是最终的代码或库，而是一种描述在某些情况下如何解决问题的方法。本文将详细介绍Java中的建造者模式（Builder Pattern），并提供一个具体的实现示例。什么是建造者模式？建造者模式是一种创建型设计模式

【详解】JAVA设计模式建造者模式（Builder）

JAVA设计模式建造者模式（Builder）

在面向对象编程中，设计模式是一种在特定情况下解决软件设计问题的通用可重用解决方案。设计模式并不是最终的代码或库，而是一种描述在某些情况下如何解决问题的方法。本文将详细介绍Java中的建造者模式（Builder Pattern），并提供一个具体的实现示例。

什么是建造者模式？

建造者模式是一种创建型设计模式，它允许你分步骤构建复杂的对象。这种模式的目的是将对象的构建过程与其表示分离，从而使相同的构建过程可以创建不同的表示。

建造者模式通常用于当需要创建的对象具有多个属性，部分属性是必需的，而其他属性是可选的时候。通过使用建造者模式，我们可以避免大量的构造函数重载，并且可以使代码更加清晰和易于维护。

建造者模式的主要角

Product (产品): 这是我们要构建的复杂对象。
Builder (抽象建造者): 提供了创建产品各个部件的接口。
ConcreteBuilder (具体建造者): 实现了Builder接口，负责构建和装配各个部件。
Director (指挥者): 负责调用具体建造者的接口来构建产品。

示例

假设我们正在开发一个系统，该系统需要创建复杂的消息。邮件消息包含多个字段，如收件人、主题、正文等。为了简化创建邮件的过程，我们可以使用建造者模式。

1. 定义产品类（Product）

代码语言：javascript代码运行次数：0运行复制

public class Email {
    private String to;
    private String subject;
    private String body;
    private List<String> attachments;

    // 私有构造函数
    private Email() {}

    public String getTo() {
        return to;
    }

    public String getSubject() {
        return subject;
    }

    public String getBody() {
        return body;
    }

    public List<String> getAttachments() {
        return attachments;
    }

    // 静态内部类，作为建造者
    public static class Builder {
        private final String to;
        private final String subject;
        private final String body;
        private List<String> attachments = new ArrayList<>();

        public Builder(String to, String subject, String body) {
             = to;
            this.subject = subject;
            this.body = body;
        }

        public Builder addAttachment(String attachment) {
            attachments.add(attachment);
            return this;
        }

        public Email build() {
            Email email = new Email();
             = to;
            email.subject = subject;
            email.body = body;
            email.attachments = attachments;
            return email;
        }
    }
}

2. 使用建造者模式创建对象

代码语言：javascript代码运行次数：0运行复制

public class EmailClient {
    public static void main(String[] args) {
        // 使用建造者模式创建Email对象
        Email email = new Email.Builder("example@example", "Hello", "This is the body of the email")
                .addAttachment("")
                .addAttachment("")
                .build();

        println("To: " + email.getTo());
        println("Subject: " + email.getSubject());
        println("Body: " + email.getBody());
        println("Attachments: " + email.getAttachments());
    }
}

. 输出结果

代码语言：javascript代码运行次数：0运行复制

To: example@example
Subject: Hello
Body: This is the body of the email
Attachments: [, ]

建造者模式是一种非常有用的设计模式，特别是在处理具有多个可选参数的对象时。通过使用建造者模式，我们可以使代码更加清晰和易于维护，同时避免了大量构造函数的重载。希望本文对您理解和应用建造者模式有所帮助。

如果您有任何问题或建议，请随时留言！当然可以！建造者模式是一种创建型设计模式，它允许你分步骤地构建复杂对象。这种模式对于那些需要通过多个参数来创建对象，并且这些参数可能有很多可选的情况特别有用。

下面是一个使用Java实现的建造者模式的实际应用场景：假设我们正在开发一个餐厅点餐系统，其中需要创建复杂的订单对象。每个订单包含多个属性，如客户姓名、、地址等。为了简化这个过程并使代码更加清晰，我们可以使用建造者模式。

1. 定义产品类（Product）

首先，定义一个表示订单的产品类 Order，这个类包含了订单的所有属性：

代码语言：javascript代码运行次数：0运行复制

public class Order {
    private String customerame;
    private String phoneumber;
    private String address;
    private String deliveryTime;
    private boolean isVegan;
    private List<String> items;

    // 私有构造方法，防止直接实例化
    private Order(Builder builder) {
         = ;
        this.phoneumber = builder.phoneumber;
        this.address = builder.address;
        this.deliveryTime = builder.deliveryTime;
        this.isVegan = builder.isVegan;
        this.items = builder.items;
    }

    // Getters for all fields
    public String getCustomerame() {
        return customerame;
    }

    public String getPhoneumber() {
        return phoneumber;
    }

    public String getAddress() {
        return address;
    }

    public String getDeliveryTime() {
        return deliveryTime;
    }

    public boolean isVegan() {
        return isVegan;
    }

    public List<String> getItems() {
        return items;
    }

    // 静态内部类 - 建造者
    public static class Builder {
        private String customerame;
        private String phoneumber;
        private String address;
        private String deliveryTime;
        private boolean isVegan;
        private List<String> items = new ArrayList<>();

        public Builder(String customerame, String phoneumber) {
             = customerame;
            this.phoneumber = phoneumber;
        }

        public Builder setAddress(String address) {
            this.address = address;
            return this;
        }

        public Builder setDeliveryTime(String deliveryTime) {
            this.deliveryTime = deliveryTime;
            return this;
        }

        public Builder setIsVegan(boolean isVegan) {
            this.isVegan = isVegan;
            return this;
        }

        public Builder addItems(List<String> items) {
            this.items.addAll(items);
            return this;
        }

        public Order build() {
            return new Order(this);
        }
    }
}

2. 使用建造者模式创建订单

接下来，我们可以通过建造者模式轻松地创建复杂的订单对象：

代码语言：javascript代码运行次数：0运行复制

public class Main {
    public static void main(String[] args) {
        // 创建一个订单
        Order order = new Order.Builder("张三", "180018000")
                .setAddress("北京市海淀区")
                .setDeliveryTime("202-10-01 18:00")
                .setIsVegan(true)
                .addItems(Arrays.asList("素菜包", "豆浆"))
                .build();

        // 输出订单信息
        println("客户姓名: " + order.getCustomerame());
        println(": " + order.getPhoneumber());
        println("地址: " + order.getAddress());
        println("送达时间: " + order.getDeliveryTime());
        println("是否素食: " + order.isVegan());
        println("点餐内容: " + order.getItems());
    }
}

. 运行结果

运行上述代码，输出结果如下：

代码语言：javascript代码运行次数：0运行复制

客户姓名: 张三
: 180018000
地址: 北京市海淀区
送达时间: 202-10-01 18:00
是否素食: true
点餐内容: [素菜包, 豆浆]

通过使用建造者模式，我们可以更方便地创建复杂的对象，而不需要在构造函数中传递大量的参数。这不仅提高了代码的可读性和可维护性，还减少了出错的可能性。建造者模式（Builder Pattern）是一种创建型设计模式，它允许你分步骤构造复杂的对象。这种模式特别适用于对象的创建过程比较复杂，且需要多个参数的情况。通过将构建逻辑和表示分离，建造者模式使得代码更加清晰、易于管理和扩展。

建造者模式的基本结构

Product（产品角）：这是被构建的复杂对象，包含多个组成部分。
Builder（抽象建造者）：为创建一个 Product 对象的各个部件指定抽象接口。
ConcreteBuilder（具体建造者）：实现 Builder 接口，构建并装配该产品的各个部件。
Director（指挥者）：构建一个使用 Builder 接口的对象。它主要是用来组织复杂对象的构建过程，指挥者不涉及具体的产品信息，只负责调用建造者的方法。
Client（客户端）：创建 Director 对象和 ConcreteBuilder 对象，并指导 Director 调用 ConcreteBuilder 的方法来构建 Product。

示例代码

假设我们要构建一个复杂的文本报告（Report），这个报告可能包含标题、作者、日期和内容等部分。

1. 产品角 - Report

代码语言：javascript代码运行次数：0运行复制

public class Report {
    private String title;
    private String author;
    private String date;
    private String content;

    // Getters and Setters
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
         = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
         = content;
    }

    @Override
    public String toString() {
        return "Report{" +
                "title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", date='" + date + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

2. 抽象建造者 - ReportBuilder

代码语言：javascript代码运行次数：0运行复制

public abstract class ReportBuilder {
    protected Report report;

    public ReportBuilder() {
        this.report = new Report();
    }

    public abstract void buildTitle(String title);
    public abstract void buildAuthor(String author);
    public abstract void buildDate(String date);
    public abstract void buildContent(String content);

    public Report getReport() {
        return report;
    }
}

. 具体建造者 - ConcreteReportBuilder

代码语言：javascript代码运行次数：0运行复制

public class ConcreteReportBuilder extends ReportBuilder {
    @Override
    public void buildTitle(String title) {
        report.setTitle(title);
    }

    @Override
    public void buildAuthor(String author) {
        report.setAuthor(author);
    }

    @Override
    public void buildDate(String date) {
        report.setDate(date);
    }

    @Override
    public void buildContent(String content) {
        report.setContent(content);
    }
}

4. 指挥者 - ReportDirector

代码语言：javascript代码运行次数：0运行复制

public class ReportDirector {
    private ReportBuilder builder;

    public ReportDirector(ReportBuilder builder) {
        this.builder = builder;
    }

    public void ctruct(String title, String author, String date, String content) {
        builder.buildTitle(title);
        builder.buildAuthor(author);
        builder.buildDate(date);
        builder.buildContent(content);
    }
}

5. 客户端 - 使用示例

代码语言：javascript代码运行次数：0运行复制

public class Client {
    public static void main(String[] args) {
        ReportBuilder builder = new ConcreteReportBuilder();
        ReportDirector director = new ReportDirector(builder);

        ("年度总结", "张三", "202-12-1", "本年度工作成果显著...");

        Report report = builder.getReport();
        println(report);
    }
}

建造者模式的主要优点是将对象的构建与表示分离，使得相同的构建过程可以创建不同的表示。这在需要创建复杂对象时非常有用，因为它可以减少代码重复，提高代码的可维护性。通过上述示例，我们可以看到如何逐步构建一个复杂的 Report 对象，而无需在每次创建时都重复相同的构建逻辑。

#感谢您对电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格的认可，转载请说明来源于"电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格

本文地址：http://www.dnpztj.cn/biancheng/1201127.html

本站网友鼢鼠	4分钟前发表
地址等
本站网友沈河租房	17分钟前发表
示例假设我们正在开发一个系统
本站网友罗塘人家	27分钟前发表
这种模式的目的是将对象的构建过程与其表示分离
本站网友杭州富阳租房	11分钟前发表
"张三"
本站网友海航地产招聘	14分钟前发表
为了简化这个过程并使代码更加清晰
本站网友欧宝汽车官网	10分钟前发表
张三
本站网友怎么去除鱼尾纹	24分钟前发表
其中需要创建复杂的订单对象
本站网友鄂温克电厂	20分钟前发表
而是一种描述在某些情况下如何解决问题的方法
本站网友国际现货黄金	30分钟前发表
为了简化创建邮件的过程
本站网友微软官网win10下载	8分钟前发表
我们可以使用建造者模式
本站网友今日网	25分钟前发表
建造者模式的基本结构Product（产品角）：这是被构建的复杂对象
本站网友林芝机场	11分钟前发表
" + order.getDeliveryTime()); println("是否素食
本站网友极光口腔	4分钟前发表
这个报告可能包含标题
本站网友 pumpitup	1分钟前发表
" + order.getCustomerame()); println("
本站网友金盏菊	21分钟前发表
易于管理和扩展
本站网友男人之痛	21分钟前发表
且需要多个参数的情况
本站网友海合会	3分钟前发表
什么是建造者模式？建造者模式是一种创建型设计模式

【详解】JAVA设计模式建造者模式（Builder）