设计模式-建造者模式（5）

最新推荐文章于 2022-11-02 18:15:02 发布
最新推荐文章于 2022-11-02 18:15:02 发布
阅读量174 收藏
点赞数
分类专栏： Play With 设计模式 文章标签： 设计模式 建造者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43891234/article/details/118672451
版权

建造者模式

1. 实例

  • 定义一个电脑类，实例化电脑类对象，以及给对象的属性赋值
// 定义一个电脑类，实例化电脑类对象，以及给对象的属性赋值

class Computer{
    private String cpu;
    private String gpu;
    private String memory;
    private String hard;

    public String getCpu() {
        return cpu;
    }

    public String getGpu() {
        return gpu;
    }

    public String getMemory() {
        return memory;
    }

    public String getHard() {
        return hard;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setGpu(String gpu) {
        this.gpu = gpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setHard(String hard) {
        this.hard = hard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", gpu='" + gpu + '\'' +
                ", memory='" + memory + '\'' +
                ", hard='" + hard + '\'' +
                '}';
    }
}

// 客户端  =======================================

public class Test01 {
    public static void main(String[] args) {
        Computer c = new Computer();
        c.setCpu("i9");
        c.setGpu("rtx3090");
        c.setHard("128T");
        c.setMemory("128g");

        System.out.println(c);
    }
}

上述方法缺点：
1. 客户端程序员，在实例化好对象后需要每个属性赋值，麻烦
2. 违反最少知道原则

建造者模式和工厂模式区别：
1. 工厂模式：实例化一个类对象即可。
2. 建造者模式：实例化对象后需要给对象属性赋值。

针对上面的问题，作者（服务端程序员）专门创建一个ComputerBuilder类，这个类专门负责封装组装电脑的过程。



// 建造者类必须关联相关产品（关联）
class ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    public Computer build(){
        computer.setCpu("i9");
        computer.setGpu("rtx3090");
        computer.setHard("128T");
        computer.setMemory("128g");
        return computer;
    }
}

// 客户端  =======================================

public class Test01 {
    public static void main(String[] args) {
        ComputerBuilder cb = new ComputerBuilder();
        Computer c = cb.build();
        System.out.println(c);
    }
}

优点： 直接通过ComputerBuilder对象build一个对象即可，不用给属性赋值

缺点： 不能自定义属性值，只有一套属性可用，如果修改，违反开闭原则。

针对上面缺点，作者多增加几个建造者类即可。LowComputerBuilder；MiddleComputerBuilder；MiddleComputerBuilder

优点：可以根据客户需求建造不同产品。

缺点：
1. 不同建造者类的build方法中有些属性可能是不变的，代码可能出现重复。
2. build过程不稳定，如果漏掉一步，代码也不会报错，该属性=null。

针对上面的问题再次修改
1. 创建一个建造者接口，所有建造者类都要实现其接口，把步骤稳定下来。
2. 少实现一个接口中的抽象方法，代码就会报错。

// 定义一个电脑类，实例化电脑类对象，以及给对象的属性赋值

class Computer{
    private String cpu;
    private String gpu;
    private String memory;
    private String hard;

    public String getCpu() {
        return cpu;
    }

    public String getGpu() {
        return gpu;
    }

    public String getMemory() {
        return memory;
    }

    public String getHard() {
        return hard;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setGpu(String gpu) {
        this.gpu = gpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setHard(String hard) {
        this.hard = hard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", gpu='" + gpu + '\'' +
                ", memory='" + memory + '\'' +
                ", hard='" + hard + '\'' +
                '}';
    }
}

interface ComputerBuilder{
    void setCpu();
    void setGpu();
    void setMemory();
    void setHard();
    Computer build();
}

// 建造者类必须关联相关产品（关联）
class HighComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    @Override
    public void setCpu() {
        computer.setCpu("i9");
    }

    @Override
    public void setGpu() {
        computer.setGpu("rtx3090");
    }

    @Override
    public void setMemory() {
        computer.setMemory("128g");
    }

    @Override
    public void setHard() {
        computer.setHard("128T");
    }

    public Computer build(){
        return computer;
    }
}

class MiddleComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    @Override
    public void setCpu() {
        computer.setCpu("i7");
    }

    @Override
    public void setGpu() {
        computer.setGpu("rtx2090");
    }

    @Override
    public void setMemory() {
        computer.setMemory("128g");
    }

    @Override
    public void setHard() {
        computer.setHard("128T");
    }

    public Computer build(){
        return computer;
    }
}

class LowComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    @Override
    public void setCpu() {
        computer.setCpu("i3");
    }

    @Override
    public void setGpu() {
        computer.setGpu("gtx1080");
    }

    @Override
    public void setMemory() {
        computer.setMemory("128g");
    }

    @Override
    public void setHard() {
        computer.setHard("128T");
    }

    public Computer build(){
        return computer;

    }
}


// 客户端
public class Test01 {
    public static void main(String[] args) {
        // 低配
        ComputerBuilder cb = new LowComputerBuilder();
        cb.setCpu();
        cb.setGpu();
        cb.setHard();
        cb.setMemory();
        Computer c = cb.build();
        System.out.println(c);

        // 中配
        ComputerBuilder cb2 = new MiddleComputerBuilder();
        cb2.setCpu();
        cb2.setGpu();
        cb2.setHard();
        cb2.setMemory();
        Computer c2 = cb2.build();
        System.out.println(c2);

        // 高配
        ComputerBuilder cb3 = new HighComputerBuilder();
        cb3.setCpu();
        cb3.setGpu();
        cb3.setHard();
        cb3.setMemory();
        Computer c3 = cb3.build();
        System.out.println(c3);
    }
}

上诉方法

优点：
1. 设置属性步骤明确，不会出错
2. 客户端可以扩展，只需要implements ComputerBuilder接口即可

缺点：
1. 客户端还是需要设置每一个属性，违反最少知道原则（迪米特法则） 。
2. 虽然不用知道装电脑的细节（cpu=“i3”）（几个螺丝，什么颜色线），但是需要知道步骤(setCpu())（先装啥再装啥）

2. 建造者模式代码

  • 分析上面例子的优缺点，有如下代码

// 定义一个电脑类，实例化电脑类对象，以及给对象的属性赋值

class Computer{
    private String cpu;
    private String gpu;
    private String memory;
    private String hard;

    public String getCpu() {
        return cpu;
    }

    public String getGpu() {
        return gpu;
    }

    public String getMemory() {
        return memory;
    }

    public String getHard() {
        return hard;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setGpu(String gpu) {
        this.gpu = gpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setHard(String hard) {
        this.hard = hard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", gpu='" + gpu + '\'' +
                ", memory='" + memory + '\'' +
                ", hard='" + hard + '\'' +
                '}';
    }
}

interface ComputerBuilder{
    void setCpu();
    void setGpu();
    void setMemory();
    void setHard();
    Computer build();
}

// 建造者类必须关联相关产品（关联）
class HighComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    @Override
    public void setCpu() {
        computer.setCpu("i9");
    }

    @Override
    public void setGpu() {
        computer.setGpu("rtx3090");
    }

    @Override
    public void setMemory() {
        computer.setMemory("128g");
    }

    @Override
    public void setHard() {
        computer.setHard("128T");
    }

    public Computer build(){
        return computer;
    }
}

class MiddleComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    @Override
    public void setCpu() {
        computer.setCpu("i7");
    }

    @Override
    public void setGpu() {
        computer.setGpu("rtx2090");
    }

    @Override
    public void setMemory() {
        computer.setMemory("128g");
    }

    @Override
    public void setHard() {
        computer.setHard("128T");
    }

    public Computer build(){
        return computer;
    }
}

class LowComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer(); // 字段关联

    @Override
    public void setCpu() {
        computer.setCpu("i3");
    }

    @Override
    public void setGpu() {
        computer.setGpu("gtx1080");
    }

    @Override
    public void setMemory() {
        computer.setMemory("128g");
    }

    @Override
    public void setHard() {
        computer.setHard("128T");
    }

    public Computer build(){
        return computer;
    }
}

// 指挥者
class Director{
    public Computer build(ComputerBuilder cb){
        cb.setCpu();
        cb.setGpu();
        cb.setHard();
        cb.setMemory();
        return cb.build();
    }
}

// =================================================================
// 客户端
// 扩展自定义配置
class SelfComputerBuilder implements ComputerBuilder{
    private Computer computer = new Computer();

    @Override
    public void setCpu() {
        computer.setCpu("1");
    }

    @Override
    public void setGpu() {
        computer.setGpu("12");
    }

    @Override
    public void setMemory() {
        computer.setMemory("123");
    }

    @Override
    public void setHard() {
        computer.setHard("1234");
    }

    @Override
    public Computer build() {
        return computer;
    }
}

public class Test01 {
    public static void main(String[] args) {
        ComputerBuilder lcb = new LowComputerBuilder();
        ComputerBuilder mcb = new MiddleComputerBuilder();
        ComputerBuilder hcb = new HighComputerBuilder();
        // 自定义
        ComputerBuilder scb = new SelfComputerBuilder();
        
        Director director = new Director(); // 指挥者

        // 低配
        Computer c = director.build(lcb);
        System.out.println(c);
        // 中配
        Computer c2 = director.build(mcb);
        System.out.println(c2);
        // 高配
        Computer c3 = director.build(hcb);
        System.out.println(c3);
        // 自定义
        Computer self = director.build(scb);
        System.out.println(self);
    }
}


输出结果:
Computer{cpu='i3', gpu='gtx1080', memory='128g', hard='128T'}
Computer{cpu='i7', gpu='rtx2090', memory='128g', hard='128T'}
Computer{cpu='i9', gpu='rtx3090', memory='128g', hard='128T'}
Computer{cpu='1', gpu='12', memory='123', hard='1234'}

上面的代码就是使用了建造者模式。

优点：
1. 创建对象的过程稳定不变，因为有ComputerBuilder接口
2. 设置对象属性封装好了，只需要编写一次（指挥者中build）
3. 客户端可以扩展功能，符合开闭原则

建造者和工厂模式区别：
1. 工厂模式只需要new一个产品即可
2. 建造者模式更加注重的是new 产品之后，对产品赋值属性的过程！

3. UML图

在这里插入图片描述

5. 原视频链接

https://www.bilibili.com/video/BV1Qx411o7tN?p=27

是杏花微雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式-建造者模式详解
11-24
Java设计模式-建造者模式详解
Java基础习题（三）
墨燚的学习之旅
11-09 5101
类与对象、封装与构造方法、继承
Java学习总结--007设计一个电脑类（学生类）computer并测试
web116629的博客
04-09 7909
设计一个电脑或者学生类，并进行测试。 需求： 1.computer类中包括牌子，系列名称，价格，生产国家四个属性； 2.分别给这几个属性，定义两种方法，一种方法用于设置值，即set方法；另一种用于获取值，即get方法； 3.computer类中定义一个无参的构造方法和一个有四个参数的构造方法； 4.在测试类中创建两个computer对象，一个使用无参构造方法，再调用方法赋值，另一个使用有参构造方法...
电脑类
Python_ID的博客
07-25 1199
# 定义一个电脑类,电脑有品牌,有价格,能放电影。 # 分别创建2个对象"联想电脑" 和 "苹果电脑"。 # 调用放电影的动作,联想电脑播放 电影"葫芦娃"，苹果电脑播放"黑猫警长"。 class Computers: """电脑类""" def __init__(self, brand, price): # 品牌 self.__brand = brand # 价格 self.__price = price def
java定义计算机类并模拟其操作
是猛男｜二次元｜玩原神｜含盐量极高｜不是GAY｜不玩币｜不接单
04-09 1347
java定义计算机类并模拟其操作 /** * 定义计算机类并模拟其操作 */ public class Computer { //成员变量 private String cpu = "Intel"; // cpu private String memory; //内存 private String mainBoard; //主板 private String keyBoard; //键盘 //构造方法 public Compu
【python基础】第02回 计算机基础2
weixin_72151603的博客
06-23 266
计算机基础
java常用设计模式-建造者模式
08-26
java常用设计模式-建造者模式
c++设计模式-创建型模式-建造者模式
06-04
c++设计模式-创建型模式-建造者模式-qt工程源码，c++实现
4.设计模式-建造者模式1
08-03
4.设计模式-建造者模式1
JAVA-设计模式-创建型模式-建造者模式
08-10
JAVA-设计模式-创建型模式-建造者模式
定义一个简单的Computer类（类的组合）
热门推荐
WeChat:A15047825994
11-10 1万+
今天做了三道C++的练习题，前两道比较简单，松松AC。关于最后一道，由于有一些C++的基础知识还没有掌握的太清楚，修改的比较多。于是就想写一下关于这道题的知识总结及其拓展延伸。 题目 定义一个简单的Computer类，有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，有两个公有成员函数run、stop。Cpu为CPU类的对象，ram为RAM类的一个对象，cdrom为CDROM类的对象，定义并实现这个类。 分析 其实是一道比较基础的组合类的问题，但是组合类的知识没有掌握的很周全，还有就是关于枚
案例~c++多态（电脑组装）
小杨的博客
02-06 261
电脑组装 #include <iostream> #include <string> using namespace std; //抽象不同零件类 //抽象CPU类 class CPU { public: //抽象的计算函数 virtual void calculate() = 0; }; //抽象显卡类 class VideoCard { public: //抽象的显示函数 virtual void display() = 0; }; //抽象内存条类 class Me
定义一个计算机类：属性：品牌；价格；颜色； 方法：（1）编程的功能 （2）上网的功能 实例化两个对象：“lenovo”；“hasee”
weixin_40678639的博客
10-23 4995
public class Computer{ public static void main(String[]args){ Com lenovo = new Com(); lenovo.brand="lenovo"; lenovo.price=4500; lenovo.color="白色"; //调用方法 lenovo.program(); lenovo.shangWang
【Java】接口练习题
专注于Java领域开发 关注我 带你玩转Java
10-24 1924
接口练习题
C++定义CPU类、RAM类、CDROM类、Computer类并实现相关提示功能，测试类的组合中构造、析构函数调用顺序和观察执行过程（C++编程实例）
m0_54158068的博客
04-11 3432
定义CPU类、RAM类、CDROM类。再定义Computer类：定义私有数据成员cpu、ram、cdrom，其中cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象。定义公有成员函数run、stop，可在其中输出提信息。主程序中定义一个Computer的对象，调用其成员函数，观察类对象及其成员变量的构造与析构顺序，以及成员函数的调用。
编写一个类Computer，类中含有一个求n的阶乘的方法。将该类打包，并在另一包中的Java文件App.java中引入包，在主类中定义Computer类的对象，调用求n的阶乘的方法（n值由参数决定），
weixin_45933223的博客
11-02 207
编写一个类Computer，类中含有一个求n的阶乘的方法。将该类打包，并在另一包中的Java文件App.java中引入包，在主类中定义Computer类的对象，调用求n的阶乘的方法（n值由参数决定），并将结果输出。
创建计算机
Self-den1al的博客
05-09 1813
定义一个简单的Computer类，有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等，有两个公有成员函数run、stop。cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，定义并实现这个类，为以上的类编写构造和析构函数，注意使用类组合的思想解决该问题，使得给出的主函数代码可以正确运行并得到给出的输出结果。 函数接口定义： 根据要求写出类的实现代码 裁判测试程序样例： /* 请在这里填写答案 */ 在这里给出函数被调用进行测试的例子。例如： in
设计模式----外观模式
qq_52269550的博客
09-19 231
文章目录前言1.门面角色：2.子系统角色：3.客户角色：4.外观模式定义5.子系统类6.门面类Facade7.客户角色8 .外观模式优点1.松散耦合2.简单易用3.更好划分访问层次 前言 外观模式就是隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。简单的说就是，这个模式把一些复杂的流程封装成一个接口供给外部用户更简单的使用 1.门面角色： 外观模式的核心。它被客户角色调用，它熟悉子系统的功能。内部根据客户角色的需求预定了几种功能的组合。（客户调用，同时自身调用子系统功能 ） 2.子系统角色： 实
Java SE基础之面向对象
zhikanjiani的博客
07-15 134
面向对象 一、类和对象 1、实际举例：一位同学高考结束，去电脑城买电脑，他要买一个游戏本，CPU、内存、显卡都要高端的，商家就把电脑拿出来给你；这个场景是我们虚构出来的，这就是一个面向对象的过程。 2、类：抽象理解为模子，并不是一个真正的实体 3、属性：一些特征：显卡、内存、CPU 4、对象的方法：打游戏、学习 5、类和对象有什么联系和区别： 类：是一个虚构的东西，是规定那一类的对象 对象：是一个...
建造者设计模式 java
最新发布
12-12
建造者设计模式是一种创建型设计模式，主要用于创建复杂对象。在Java中，建造者设计模式通常由一个具体建造者类和一个指挥者类组成。 具体建造者类负责定义创建对象的各个部件的具体实现方法，而指挥者类则负责协调...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值