设计模式之建造者模式

最新推荐文章于 2024-11-07 14:01:54 发布
最新推荐文章于 2024-11-07 14:01:54 发布
阅读量150 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41884521/article/details/107613152
版权

建造者模式

需求： 定义一个电脑类，并实例化该电脑类对象，并为该对象的属性赋值

1、平时创建对象并赋值的方式

平时，我们在实例化对象之后必须为该对象的每一个属性赋值，这样对我们来说太麻烦了，而且还违反了迪米特法则。

我们的例子来说，这就相当于我们我们去买电脑，商家把所有配件给我们，叫我们自己组装

class Computer {
    private String cpu;
    private String gpu;
    private String memery;
    private String hd;

   //....省略get，set方法以及toString方法
}
//以上为客户端，以下为服务端，我们角色为客户（客户端可以随意修改，服务端我们不能操作）
//====================================================================
public class AppTest {

    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu("");
        computer.setGpu("");
        computer.setHd("");
        computer.setMemery("");
    }

这样做的缺点是：

  1. 客户端程序员在实例化产品对象之后，必须为该对象的每一个属性赋值，这样对于客户端程序员来讲，太麻烦了。
  2. 违背了迪米特法则

建造者模式与工厂模式的区别：
工厂模式：是直接实例化出一个类的对象即可
建造者模式：实例化类的对象之后，还要给类的属性赋值

2、创建一个专门用于创建电脑的建造类

针对上面的问题，我们专门创建一个ComputerBuilder类，专门用于创建对象

class Computer {
    private String cpu;
    private String gpu;
    private String memery;
    private String hd;
    //省略get，set，toString方法
}

//低配电脑
class LowComputerBuilder {
    private Computer computer = new Computer();
    public Computer build(){
        computer.setCpu("");
        computer.setGpu("");
        computer.setHd("");
        computer.setMemery("");
        return computer;
    }
}

//中配电脑
class MiddleComputerBuilder {
    private Computer computer = new Computer();
    public Computer build(){
        computer.setCpu("");
        computer.setGpu("");
        computer.setHd("");
        computer.setMemery("");
        return computer;
    }
}

//高配电脑
class HeightComputerBuilder {
    private Computer computer = new Computer();
    public Computer build(){
        computer.setCpu("");
        computer.setGpu("");
        computer.setHd("");
        computer.setMemery("");
        return computer;
    }
}

//====================================================================
public class AppTest {
    public static void main(String[] args) {
        //购买低配电脑
        LowComputerBuilder c1 = new LowComputerBuilder();
        Computer build = c1.build();

        //购买中配电脑
        MiddleComputerBuilder c2 = new MiddleComputerBuilder();
        Computer build1 = c2.build();

        //购买高配电脑
        HeightComputerBuilder c3 = new HeightComputerBuilder();
        Computer build2 = c3.build();
    }
}

这样设计仍然不属于建造者模式。
优点：

  1. 可以根据不同的需求，使用不同的建造着来进行生产

缺点：

  1. 我们发现不同的建造者中的代码，在重复，既然代码中出现了重复的代码，那就有了“坏味道”
  2. 建造的过程不稳定，如果在建造者在建造的过程中，如果漏掉了某一部（比如创建的过程中中cup，gpu，hq都装了，但是没有装memary），编译器也不会报错。（举个例子来说，就类似于KFC的某一家分店，在制作汉堡包的过程中突然少了某一个步骤，出来的汉堡包的味道就变了，因为没有标准）

3、创建规范接口，规范创建的类

针对2中产生的问题，修改代码如下：
创建一个建造者接口，吧制作的具体流程稳定下来，我们让建造者类去实现建造者接口，接口中的方法步骤类都必须进行实现，少实现一个抽象方法就会报错。

class Computer {
    private String cpu;
    private String gpu;
    private String memery;
    private String hd;
    // .....   此处省略get，set方法
}

interface ComputerBuilder {
    void setCpu();
    void setGpu();
    void setHd();
    void setMemary();
    Computer build();
}
//低配
class LowComputer implements ComputerBuilder{
    private Computer c = new Computer();

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

    @Override
    public void setGpu() {
        c.setGpu("2");
    }

    @Override
    public void setHd() {
        c.setHd("3");
    }

    @Override
    public void setMemary() {
        c.setMemery("4");
    }

    @Override
    public Computer build() {
        return c;
    }
}
//中配
class MiddleComputer implements ComputerBuilder{
    private Computer c = new Computer();

    @Override
    public void setCpu() {
        c.setCpu("3");
    }

    @Override
    public void setGpu() {
        c.setGpu("3");
    }

    @Override
    public void setHd() {
        c.setHd("3");
    }

    @Override
    public void setMemary() {
        c.setMemery("3");
    }

    @Override
    public Computer build() {
        return c;
    }
}
//高配
class HeightComputer implements ComputerBuilder{
    private Computer c = new Computer();

    @Override
    public void setCpu() {
        c.setCpu("4");
    }

    @Override
    public void setGpu() {
        c.setGpu("4");
    }

    @Override
    public void setHd() {
        c.setHd("4");
    }

    @Override
    public void setMemary() {
        c.setMemery("4");
    }

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

//====================================================================
public class AppTest {

    public static void main(String[] args) {
        LowComputer c1 = new LowComputer();
        MiddleComputer c2 = new MiddleComputer();
        HeightComputer c3 =  new HeightComputer();
        //低配电脑
        c1.setCpu();
        c1.setGpu();
        c1.setHd();
        c1.setMemary();
        Computer build = c1.build();

        //中配电脑
        c2.setCpu();
        c2.setGpu();
        c2.setHd();
        c2.setMemary();
        Computer build1 = c2.build();

        //高配电脑
        c3.setCpu();
        c3.setGpu();
        c3.setHd();
        c3.setMemary();
        Computer build2 = c3.build();

        System.out.println(build);
        System.out.println(build1);
        System.out.println(build2);
    }
}

这个还不是构造者模式，
优点：

  1. 建造类中建造过程使稳定的，不会漏掉某一步，这样客户端想要扩展建造者时，也不会漏掉某一步。

缺点：

  1. 代码任然重复
  2. 现在又变成了客户端自己来进行配置电脑，又违反了迪米特法则（着相当于你去赛格配置电脑，虽然不用你亲自组装电脑，但是你必须指挥那个组装电脑的人，该装什么该装什么），如果你在指挥的过程中如果漏了哪一步，依旧会使该电脑缺少一些部件或者功能。

4、创建一个指挥者，用于创建电脑（这就是建造者模式）

针对上面的的问题，我们创建一个指挥者Director，用于指挥商品的创建

class Computer {
    private String cpu;
    private String gpu;
    private String memery;
    private String hd;
    // .... 此处省略get set方法
}

interface ComputerBuilder {
    void setCpu();
    void setGpu();
    void setHd();
    void setMemary();
    Computer build();
}
//低配
class LowComputer implements ComputerBuilder{
    private Computer c = new Computer();

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

    @Override
    public void setGpu() {
        c.setGpu("2");
    }

    @Override
    public void setHd() {
        c.setHd("3");
    }

    @Override
    public void setMemary() {
        c.setMemery("4");
    }

    @Override
    public Computer build() {
        return c;
    }
}
//中配
class MiddleComputer implements ComputerBuilder{
    private Computer c = new Computer();

    @Override
    public void setCpu() {
        c.setCpu("3");
    }

    @Override
    public void setGpu() {
        c.setGpu("3");
    }

    @Override
    public void setHd() {
        c.setHd("3");
    }

    @Override
    public void setMemary() {
        c.setMemery("3");
    }

    @Override
    public Computer build() {
        return c;
    }
}
//高配
class HeightComputer implements ComputerBuilder{
    private Computer c = new Computer();

    @Override
    public void setCpu() {
        c.setCpu("4");
    }

    @Override
    public void setGpu() {
        c.setGpu("4");
    }

    @Override
    public void setHd() {
        c.setHd("4");
    }

    @Override
    public void setMemary() {
        c.setMemery("4");
    }

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

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

//====================================================================
public class AppTest {

    public static void main(String[] args) {
        Director director = new Director();

        LowComputer c1 = new LowComputer();
        MiddleComputer c2 = new MiddleComputer();
        HeightComputer c3 =  new HeightComputer();
        //低配电脑
        Computer build = director.build(c1);
        //中配电脑
        Computer build1 = director.build(c2);
        //高配电脑
        Computer build2 = director.build(c3);

        System.out.println(build);
        System.out.println(build1);
        System.out.println(build2);
    }
}

这就是建造者模式
优点：

  1. 创建过程是稳定不变的（因为有ComputerBuilder接口来稳定过程）
  2. 创建过程只写了一次，没有重复的代码（由Director指挥完成）

以上内容为课后总结，如有侵权，请告知本人！

baby-shi
关注
专栏目录
【设计模式】建造者模式
阳阳的博客
12-05 645
一、前言 什么是建造者模式？或许我们对这个模式一点都不了解的。但链式调用你总写过吧，那就是建造者模式。 我举个栗子： 这是一个okhttp3使用的栗子： Request request = new Request.Builder() .url(url) .post(requestBody) ...
构建者模式
叶存菜鸟博客
05-12 177
构建者模式： 将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。 例： 向外界提供一个 接口调用，消费者只需关心功能 电脑接口: /** * 电脑接口 */ public interface Computer { void doInternet(); // 上网冲浪 void showMovie(); // 上网看电视 } 接口实现： 问题： 电脑实现类，有些配置信息，需要再次去设定，设定较为复杂，如果放在构造方法内，代码耦合性高，灵活性也很低； /*
设计模式——建造者模式
Olive的博客
12-15 355
一、什么是建造者模式？   当一个对象的创建包含该对象的部件部分及部件的装配过程时，建造者模式可以将对象的部件生成过程及装配过程进行分离解耦，从而使系统结构变得更加清晰。举个栗子：我们知道电脑是由CPU，硬盘和内存组成的，那么如果我们要创建一个电脑，首先的思路就是我们去制造CPU、硬盘和内存，然后进行组装，这样就生成了一台电脑。仔细一想，这个模式存在很多问题，它将部件的生成和组装放在了一起，那
设计模式学习笔记（C++实现）（四）--建造者模式
以文会友
05-20 595
1.建造者模式简介 英文名称 Builder 主要目的 该模式可以将一个复杂对象的构建和其的表示分离，使得同样的构建过程可以创建不同的表示。 使用场景 1.当构建复杂对象的算法应该独立于该对象的组成部分以及其装配方式时； 2.当构建过程必须允许被构建对象有不同的表示时。 2.建造者模式代码示例 测试平台 1.开发语言：C++ 2.开发工具：VS2015 3.操作系统：Wi...
设计模式-（6）建造者模式（Builder Pattern）
num197的专栏
05-12 192
一、引言 　　在软件系统中，有时需要创建一个复杂对象，并且这个复杂对象由其各部分子对象通过一定的步骤组合而成。例如一个采购系统中，如果需要采购员去采购一批电脑时，在这个实际需求中，电脑就是一个复杂的对象，它是由CPU、主板、硬盘、显卡、机箱等组装而成的，如果此时让采购员一台一台电脑去组装的话真是要累死采购员了，这里就可以采用建造者模式来解决这个问题，我们可以把电脑的各个组件的组装过程封装到一个建...
设计模式之建造者模式详解
猫猫爱吃小鱼粮
03-25 1263
设计模式之建造者模式详解
Java设计模式之建造者模式实例详解
08-29
"Java设计模式之建造者模式实例详解" 本文主要介绍了Java设计模式之建造者模式，结合具体实例形式分析了建造者模式的概念、原理、实现方法与相关使用注意事项。 建造者模式的概念 建造者模式（Builder Pattern）...
JavaScript设计模式之建造者模式实例教程
01-19
本文实例讲述了JavaScript设计模式之建造者模式。分享给大家供大家参考，具体如下： 一、建造者模式模式概念 建造者模式可以将一个复杂的对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。也就是说...
Java创建型设计模式之建造者模式详解.rar
07-10
建造者模式是软件设计模式中的一种，属于创建型模式，它的主要目的是将对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。在Java中，建造者模式经常用于构造复杂对象，通过一步一步地创建对象，使得...
设计模式-建造者模式(Builder)
听雪楼
11-22 326
建造者模式(Builder) 定义 : 将一个复杂对象的构建与它的表示分离, 是的同样的构建过程可以创建不同的表示 用户只需指定需要建造的类型就可以得到它们, 建造过程及细节不需要知道 类型 : 创建型设计模式 适用场景 一个对象有非常复杂的内部结构 想把复杂对象的创建和使用分离 优点 封装性好, 创建和使用分离 扩展性好, 建造类之间独立, 一定程度上解耦 缺点 产生多余的Buil...
c++设计模式demo
jianfeng123123的博客
11-06 657
⾼层模块不应该依赖低层模块，⼆者都应该依赖抽象；抽象不应该依赖具体实现，具体实现应该依赖于抽象；⾃动驾驶系统公司是⾼层，汽⻋⽣产⼚商为低层，它们不应该互相依赖，⼀⽅变动另⼀⽅也会跟着变动；⽽应该 抽象 ⼀个⾃动驾驶⾏业标准，⾼层和低层都依赖它；这样以来就解耦了两⽅的变动；⾃动驾驶系统、汽⻋⽣产⼚商都是具体实现，它们应该都依赖⾃动驾驶⾏业标准（抽象）；⼀个类应该对扩展开放，对修改关闭；不将变量类型声明为某个特定的具体类，⽽是声明为某个接⼝。
JavaScript 23种经典设计模式简介
前端梦工厂
11-06 909
23种JavaScript经典设计模式。
设计模式之——观察者模式
最新发布
m0_71974552的博客
11-07 915
深入理解观察者模式：高效解耦的设计利器
设计模式小结一策略（strategy）模式
sunxingzhesunjinbiao的专栏
11-04 1219
定义一个策略接口，包含一个计算折扣价格的方法。// 折扣策略接口创建类，用于设置折扣策略，并计算折扣后的价格。// 设置折扣策略// 计算折扣价格throw new IllegalStateException("折扣策略未设置");
Unity中RTS游戏的设计模式处理： 游戏中的对象选择和命令委托的基本框架
网易搬砖选手
11-06 171
单个集中类（例如，）跟踪当前选择的单元/对象，并处理用于选择游戏中对象的任何光线投射逻辑。可选对象附加了一个组件，其中公开了一个公共函数，该函数返回一个实现该接口的类。类实现特定于控制单个单元的自定义逻辑。这是通过一个公共函数完成的，每次玩家单击一个新对象时都会调用该函数。当玩家单击屏幕时，单个类会进行光线投射，以获取有关单击哪个对象的信息。该类还跟踪当前正在控制的单元，并将新单击的对象提供给该单元的控制逻辑。如果没有选择任何内容，我们将尝试选择接下来单击的对象。
MVC（Model-View-Controller）模式概述
Joshua的专栏
11-03 637
以下是对 Smalltalk 的 MVC 架构模式的设计思想、采用的重要设计模式以及其后续发展的详细说明。Smalltalk 的 MVC 架构模式不仅是一种设计思想，也是一系列设计模式的集合，旨在实现软件开发中关注点的分离。这种设计模式有效地提高了程序的可维护性和可扩展性，并在后续的编程语言和开发框架中得到了广泛运用和发展。MVC 的演变和适应现代需求的能力，展示了其在软件设计领域的重要性和持久性。MVC 模式在 Smalltalk 的成功应用之后，广泛影响了后续的编程语言和开发框架。
深入理解C++设计模式：建造者模式详解
资源摘要信息:"c++-设计模式之‘建造者模式（Builder）’" 建造者模式（Builder Pattern）是一种创建型设计模式，它的主要作用是将一个复杂对象的构建与它的表示分离，从而使得同样的构建过程可以创建不同的表示。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值