3_建造者模式

最新推荐文章于 2024-11-09 23:29:17 发布
最新推荐文章于 2024-11-09 23:29:17 发布
阅读量153 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式
By_Code27
本文链接：https://blog.csdn.net/XJ0927/article/details/109557240
版权

3_建造者模式

简述：建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

也就是说不仅仅是关注 new 对象的结果，更注重对象属性的赋值过程！

实体类 #：

public class Computer {
    private  String cpu;
    private String gpu;
    private String memory;
    private  String Hd;

    public String getCpu() {
        return cpu;
    }

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

    public String getGpu() {
        return gpu;
    }

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

    public String getHd() {
        return Hd;
    }

    public void setHd(String hd) {
        Hd = hd;
    }

    public String getMemory() {
        return memory;
    }

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

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", gpu='" + gpu + '\'' +
                ", memory='" + memory + '\'' +
                ", Hd='" + Hd + '\'' +
                '}';
    }
}
反例 #1 ：

现在开始创建对象 。

public class Negative {
    public static void main(String[] args) {
        Computer computer1 = new Computer();
        computer1.setCpu("9700k");
        computer1.setGpu("gtx2080ti");
        computer1.setMemory("16g");
        computer1.setHd("机械1T");

        Computer computer2 = new Computer();
        computer2.setCpu("9600k");
        computer2.setGpu("gtx1080ti");
        computer2.setMemory("32g");
        computer2.setHd("固态500G");

        System.out.println(computer1);
        System.out.println(computer2);
    }
}

缺陷： 建造复杂对象的时候，客户端程序要炸，造成客户端代码臃肿，且违反迪米特法则（最少知道原则） 。

反例 #2：

将属性赋值过程使用一个建造类封装起来，但此时仍然还不是建造者模式 。

public class Negative2 {
    /*=============服务端==========================*/
    static class HighComputerBuilder {
        private Computer computer = new Computer();

        public Computer build() {
            computer.setCpu("9700k");
            computer.setGpu("gtx2080ti");
            computer.setHd("固态1T");
            computer.setMemory("32G");
            return computer;
        }
    }

    static class MiddleComputerBuilder {
        private Computer computer = new Computer();

        public Computer build() {
            computer.setCpu("9600k");
            computer.setGpu("gtx1080ti");
            computer.setHd("固态500G");
            computer.setMemory("16G");
            return computer;
        }
    }
    /*=====================客户端===============================*/
    public static void main(String[] args) {
        HighComputerBuilder builder1 = new HighComputerBuilder();
        Computer computer1 =builder1.build();

        MiddleComputerBuilder builder2 = new MiddleComputerBuilder();
        Computer computer2 =builder2.build();

        System.out.println(computer1);
        System.out.println(computer2);
    }
}

UML类图如下：

在这里插入图片描述

缺陷：建造者遗漏部分建造步骤，编译也会通过，会造成建造出来的对象不符合要求。比如，漏执行某一步骤时，使得部分值为 null ，后续对象属性被调用时，可能会抛出空指针NullPointerException异常，会造成程序崩溃。

反例 #3：

定义一个建造者接口来进行规范 。

public class Negative3 {
    /*=============服务端==========================*/
    /***定义一个建造者接口进行规范****/
    interface ComputerBuilder{
        Computer build();
        void setCpu();
        void setGpu();
        void setMemory();
        void setHd();
    }
    
    static class HighComputerBuilder implements ComputerBuilder{

        private Computer computer = new Computer();

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

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

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

        @Override
        public void setHd() {
            computer.setHd("固态1T");
        }

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

    static class MiddleComputerBuilder implements ComputerBuilder{

        private Computer computer = new Computer();

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

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

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

        @Override
        public void setHd() {
            computer.setHd("固态500G");
        }

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

    /*==============客户端=====================================*/
    public static void main(String[] args) {
        HighComputerBuilder builder1 = new HighComputerBuilder();
        builder1.setCpu();
        builder1.setGpu();
        builder1.setHd();
        builder1.setMemory();
        Computer computer1 =builder1.build();

        MiddleComputerBuilder builder2 = new MiddleComputerBuilder();
        builder2.setCpu();
        builder2.setGpu();
        builder2.setHd();
        builder2.setMemory();
        Computer computer2 =builder2.build();

        System.out.println(computer1);
        System.out.println(computer2);
    }
}

创造了建造者接口，创建者不会再遗漏步骤。

UML类图如下：

在这里插入图片描述

缺陷：

  • 每一个builder都要自己去调用setXXX方法进行创建，造成代码重复。
  • 需要客户端自己执行创建步骤，建造复杂对象的时候，容易造成客户端代码臃肿，且违反迪米特法则（最少知道原则)。而且客户端会出现遗漏步骤的情况。感觉又回到了原点 。
正例 #1：

将属性赋值步骤，交给一个指挥者，让它去指挥建造者完成，我们只需要安排指挥者就行 。

public class Negative3 {
    /*=============服务端==========================*/
    interface ComputerBuilder {
        Computer build();

        void setCpu();

        void setGpu();

        void setMemory();

        void setHd();
    }

    static class HighComputerBuilder implements ComputerBuilder {

        private Computer computer = new Computer();

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

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

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

        @Override
        public void setHd() {
            computer.setHd("固态1T");
        }

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

    static class MiddleComputerBuilder implements ComputerBuilder {

        private Computer computer = new Computer();

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

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

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

        @Override
        public void setHd() {
            computer.setHd("固态500G");
        }

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

    //--------------指挥者---------------//
    static class Director {
        public Computer build(ComputerBuilder builder) {
            builder.setCpu();
            builder.setGpu();
            builder.setMemory();
            builder.setHd();
            return builder.build();
        }
    }


    /*==============客户端=====================================*/
    public static void main(String[] args) {

        HighComputerBuilder hcb = new HighComputerBuilder();
        MiddleComputerBuilder mcb = new MiddleComputerBuilder();

        Director director = new Director();
        Computer computer1 = director.build(hcb);
        Computer computer2 = director.build(mcb);

        System.out.println(computer1);
        System.out.println(computer2);
    }
}

UML类图如下：
在这里插入图片描述

此时在需要增加一个不同配置的 LowComputer 类型计算机，只需要编写一个LowComputerBuilder类实现 ComputerBuilder 接口，再传给指挥者 Director 进行创建即可得到一个 LowComputer 类型的 Computer 对象。符合开闭原则 。

总结一下建造者模式的优点：

  • 创建对象的过程保持稳定。（通过 ComputerBuilder 接口保持稳定）
  • 创建过程只需要编写一次（通过实现 ComputerBuilder 接口的类保持稳定）
  • 保持扩展性，需要创建新类型的对象时，只需要创建新的 Builder ，再使用指挥者 Director 进行调用进行创建即可。
  • 增加指挥者 Director 保证步骤稳定执行，客户端不需要知道创建对象的具体步骤，符合迪米特法则(最少知道原则）。

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

  • 工厂模式注重new一个对象就可以，是否得到了这一对象，更多地关注new的结果。
  • 建造者模式注重保证new的对象稳定可用，保证不出现细节缺漏，更多关注new的细节、过程。
建造者模式
a1050122092的博客
07-20 159
一.经典呈现 1.定义 建造者模式（Builder）将复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 2.建造者模式结构 3.模式的组成 （1）抽象建造者角色（Builder）：为创建一个Product对象的各个部件指定抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此角色规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。 （2）具体建造者...
Java建造者模式以及常见误区错误分析纠正
poyuan97的博客
09-24 645
设计模式复习，代码是最好的说明。 注意： 在写建造者模式的时候，我发现大部分文章都犯了不少错误，猜测应该是由于缺乏独立思考而又都参考了同一篇含错误的源文章导致的。现总结如下： 问题1：混淆director和builder的关系，如http://blog.csdn.net/zhengzhb/article/details/7375966 解决：builder的接口应该是定
学了这个，再也不想写各种setter了
dabaoshiwode的博客
10-17 159
今天又来给大家吹一下逼。在公司里边也看了不少的系统了，看到结构清晰、代码清晰的系统时会赞叹能写出这种代码的人是真的牛逼。看到乱七八糟的代码又不写注释的时候也会吐槽：“这写的是啥啊”多看别...
设计模式之建造者模式
针线犹存未忍开
08-27 1284
*** @Description: 设置电脑属性的接口*/提供了将复杂对象的构建过程和表示分离的能力，使得构建过程可以独立于表示而变化。可以隐藏复杂对象的创建细节，使得客户端代码可以直接使用已经构建好的对象，而不需要知道具体的构建过程。可以通过改变具体的建造者和指导者来创建不同的产品，使得客户端代码可以使用不同的建造者来构建不同的产品实例。可以避免在客户端代码中直接创建复杂对象，从而提高代码的可维护性和可扩展性。
瑞_23种设计模式_建造者模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
02-04 2199
本文章为瑞_系列专栏之《23种设计模式》的建造者者模式篇。建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
设计模式——建造者模式
weixin_46073538的博客
07-10 1301
建造者模式(Builder Pattern)又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别)，使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们.用户不需要知道内部的具体构建细节。
设计模式 - 创建型模式_建造者模式
热门推荐
小工匠
01-27 2万+
建造者模式所完成的内容就是通过将多个简单对象通过⼀步步的组装构建出⼀个复杂对象的过程。举个例子玩王者荣耀的时的初始化界⾯；有三条路、有树⽊、有野怪、有守卫塔等等，甚⾄依赖于你的⽹络情况会控制清晰度。⽽当你换⼀个场景进⾏其他不同模式的选择时，同样会建设道路、树⽊、野怪等等，但是他们的摆放和⼤⼩都有不同。这⾥就可以⽤到建造者模式来初始化游戏元素。⽽这样的根据相同的物料 ，不同的组装所产⽣出的具体的内容，就是建造者模式的最终意图，也就是将⼀个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
【设计模式】建造者模式
言之。
07-24 1万+
建造者模式是一种创建对象的设计模式，它将复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。在建造者模式中，有一个导演（Director）类和一个建造者（Builder）抽象类及其具体的建造者子类。导演类负责控制构建产品的流程，而具体的建造者子类负责实现产品的具体构建过程。
Java设计模式——建造者模式
2302_77758423的博客
06-03 1474
建造者模式是一种强大的工具，可以帮助我们更好地组织和管理复杂对象的创建过程。通过将对象的构建过程与其表示分离，我们可以更灵活地控制对象的创建，并提高代码的可读性和可维护性。
C++ 设计模式——建造者模式
qq_68194402的博客
08-18 1444
建造者模式（Builder Pattern）是一种创建型设计模式，它允许使用多个简单的对象一步步构建一个复杂的对象。建造者模式通过将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。
第7章_建造者模式.ppt
03-30
而对于大多数用户而言，无须知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完整的汽车，可以通过建造者模式对其进行设计与描述，建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的...
Python3实现建造者模式的示例代码
09-16
通过这个例子，我们可以看到Python3如何使用建造者模式来构建一个复杂对象。这种方式使得代码更加模块化，易于维护，同时也提高了代码的可读性和可扩展性。当需要构建的对象有多种变体或构建过程复杂时，建造者模式...
java实现建造者模式（Builder Pattern）
08-26
java实现建造者模式（Builder Pattern） java实现建造者模式（Builder Pattern）是一种软件设计模式，旨在解决软件系统中创建复杂对象的问题。建造者模式可以将复杂对象的创建过程分解为多个简单的对象一步一步构建...
设计模式之建造者模式代码示例
08-20
建造者模式（Builder Pattern）是软件工程中一种用于创建对象的抽象工厂方法，它将复杂的构建过程分解为一系列步骤，使得构建过程可以独立于其表示进行。这种模式允许客户端使用相同的构建过程创建不同表现形式的...
JavaScript 23种经典设计模式简介
前端梦工厂
11-06 1207
23种JavaScript经典设计模式。
设计模式学习总结（一）
最新发布
huanggang982的专栏
11-09 389
设计模式学习笔记面向对象、设计原则、设计模式、编程规范、重构之间的关系 面向对象、设计原则、设计模式、编程规范、重构之间的关系 面向对象 现在，主流的编程范式或者是编程风格有三种：面向过程、面向对象和函数式编程。 需要掌握七大知识点： 1、面向对象的四大特性：封装、抽象、继承、多态 2、面向对象编程与面向过程编程的区别和联系 3、面向对象分析、面向对象设计、面向对象编程 4、接口和抽象类的区别以及各自的应用场景 5、基于接口而非实现编程的设计思想 6、多用组合少用继承的设计思想 7、面向过程的贫血模型和面
备忘录模式：保存对象状态的设计模式
wrxfxdd的博客
11-06 606
备忘录模式：保存对象状态的设计模式
Unity中RTS游戏的设计模式处理： 游戏中的对象选择和命令委托的基本框架
网易搬砖选手
11-06 476
单个集中类（例如，）跟踪当前选择的单元/对象，并处理用于选择游戏中对象的任何光线投射逻辑。可选对象附加了一个组件，其中公开了一个公共函数，该函数返回一个实现该接口的类。类实现特定于控制单个单元的自定义逻辑。这是通过一个公共函数完成的，每次玩家单击一个新对象时都会调用该函数。当玩家单击屏幕时，单个类会进行光线投射，以获取有关单击哪个对象的信息。该类还跟踪当前正在控制的单元，并将新单击的对象提供给该单元的控制逻辑。如果没有选择任何内容，我们将尝试选择接下来单击的对象。
【Rust设计模式之Fold模式】
m0_37719524的博客
11-08 413
如Rust Collection中的fold方法，是消耗迭代器适配器，将闭包应用于每一个元素，并将结果返回一样。Fold模式的中心思想也是如此，将元素折叠处理，最终计算出新的元素。而我们自己实现的Fold模式，一般用于映射数据结构，不同于面向对象的原地修改，由于Rust的引用和借用以及不可变性，生成新的结构从而替代老的结构调理更为清晰。总结：通常来说只有我们在自己编写一些数据结构的时候方才用得到这种fold模式，一般的业务逻辑相对的较少能够涉及到此，不过多懂一些也是极好的~“万全之计便是即刻行动”
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值