建造者模式(构建者模式)链式编程实现

在这里插入图片描述

0. 定义

建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式;
简单来说:将对象一步步的组装构建;
罗马不是一天建成的,建造者模式可以一点一点去构建

1. lombok的构建者模式:@Builder

  1. 实体:
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Order {

    private Integer id;
    private String name;
    private Double price;
    private Date time;

}
  1. lombok的构建者模式:
public class OrderTest {
    public static void main(String[] args) {
        Order order = Order.builder()
                .name("心留时间")
                .price(32d)
                .id(1)
                .time(new Date())
                .build();
        System.out.println(order);
    }
}

在这里插入图片描述

2. 自己实现构建者模式

  1. pojo代码:
package com.xin.demo.pojo.domain;

import java.util.Date;

public class Order {

    private Integer id;
    private String name;
    private Double price;
    private Date time;




    private Order(OrderBuilder OrderBuilder){
        this.id = OrderBuilder.id;
        this.name = OrderBuilder.name;
        this.price = OrderBuilder.price;
        this.time = OrderBuilder.time;
    }

    public static class OrderBuilder {

        private Integer id;
        private String name;
        private Double price;
        private Date time;

        public OrderBuilder id (Integer id){
            this.id = id;
            return this;
        }

        public OrderBuilder name (String name){
            this.name = name;
            return this;
        }

        public OrderBuilder price (Double price){
            this.price = price;
            return this;
        }

        public OrderBuilder time (Date time){
            this.time = time;
            return this;
        }


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

    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", time=" + time +
                '}';
    }
}
  1. 使用
package com.xin.demo.pojo.domain;

import java.util.Date;

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order.OrderBuilder()
                .name("心留时间")
                .price(32d)
                .id(1)
                .time(new Date())
                .build();
        System.out.println(order);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
建造者模式是一种创建型设计模式,它允许逐步创建复杂对象,同时使得创建过程更加灵活。在 C++ 中,可以使用类和对象来实现建造者模式。 以下是一个使用 C++ 实现建造者模式的示例: 首先,我们需要定义一个产品类,该类包含了需要创建的对象的属性: ```cpp class Product { public: void setPartA(const std::string& partA) { this->partA = partA; } void setPartB(const std::string& partB) { this->partB = partB; } void setPartC(const std::string& partC) { this->partC = partC; } std::string getInfo() const { return "Part A: " + partA + ", Part B: " + partB + ", Part C: " + partC; } private: std::string partA; std::string partB; std::string partC; }; ``` 接下来,我们需要定义一个抽象建造者类,该类定义了创建产品所需的所有方法: ```cpp class Builder { public: virtual void buildPartA() = 0; virtual void buildPartB() = 0; virtual void buildPartC() = 0; virtual Product* getResult() = 0; }; ``` 然后,我们可以定义具体的建造者类,该类实现了抽象建造者类中定义的所有方法,并负责创建具体的产品对象: ```cpp class ConcreteBuilder : public Builder { public: ConcreteBuilder() { product = new Product(); } void buildPartA() override { product->setPartA("Part A"); } void buildPartB() override { product->setPartB("Part B"); } void buildPartC() override { product->setPartC("Part C"); } Product* getResult() override { return product; } private: Product* product; }; ``` 最后,我们需要定义一个指挥者类,该类负责使用建造者对象来构建具体的产品: ```cpp class Director { public: void construct(Builder* builder) { builder->buildPartA(); builder->buildPartB(); builder->buildPartC(); } }; ``` 现在,我们可以使用建造者模式来创建具体的产品对象: ```cpp int main() { Director director; ConcreteBuilder builder; director.construct(&builder); Product* product = builder.getResult(); std::cout << product->getInfo() << std::endl; return 0; } ``` 输出结果为: ``` Part A: Part A, Part B: Part B, Part C: Part C ``` 这就是一个简单的 C++ 建造者模式实现

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值