设计模式之建造者模式

最新推荐文章于 2024-10-04 08:38:41 发布
最新推荐文章于 2024-10-04 08:38:41 发布
阅读量121 收藏
点赞数
分类专栏： # 设计模式 文章标签： 设计模式 建造者模式 过程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42947972/article/details/108338635
版权

建造者模式

  • 逐步推导建造者模式的由来
  • 需求:
    • 定义一个电脑类,并且实例化出电脑类的对象,以及给该对象的属性赋值
  • 未使用建造者模式
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 getMemory() {
        return memory;
    }

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

    public String getHd() {
        return hd;
    }

    public void setHd(String hd) {
        this.hd = hd;
    }

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

//=======================时空线=============================
//=========上面为服务端(提供服务,作者),下面为客户端(使用服务)=====

public class AppTest {

    public static void main(String[] args) {
        Computer c = new Computer();
        c.setCpu("i7 7500u");
        c.setGpu("gt940mx");
        c.setMemory("16g");
        c.setHd("1T机械");

        System.out.println(c);
    }
}
  • 这样做的缺点:
    1. 客户端程序猿在实例化好产品的对象之后,必须为该对象的每一个属性赋值,这样对客户端程序猿来说,太麻烦了!
    2. 违反了迪米特法则(最少知道原则), 客户端程序猿知道得太多了
    • 这相当于你去配置电脑,商家把零件全给你,你自己组装电脑!
  • 针对上面两个问题,修改代码如下:
    • 作者,专门创建一个"ComputerBuilder" 类,这个类专门封装组装电脑的过程
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 getMemory() {
        return memory;
    }

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

    public String getHd() {
        return hd;
    }

    public void setHd(String hd) {
        this.hd = hd;
    }

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

// 电脑建造者,建造者类,必须关联电脑产品
class ComputerBuilder {
    private Computer computer = new Computer();

    public Computer build() {
        computer.setCpu("i7 8750HK");
        computer.setGpu("rtx2080Ti");
        computer.setMemory("32g");
        computer.setHd("500g固态+2T机械");
        return computer;
    }
}

//=======================时空线=============================
//=========上面为服务端(提供服务,作者),下面为客户端(使用服务)=====
public class AppTest {

    public static void main(String[] args) {

       //创建一个建造者
        ComputerBuilder cb = new ComputerBuilder();

        //玩游戏
        Computer c = cb.build();
        System.out.println(c);

        //开发
        Computer c2 = cb.build();
        System.out.println(c2);

        //办公娱乐
        Computer c3 = cb.build();
        System.out.println(c3);
    }
}
  • 目前的这种写法还不是建造模式
    • 目前的优点:
      1. 客户端程序猿需要一个产品时,直接向建造者要即可,建造者封装了创建电脑的"复杂"过程
    • 目前的缺点:
      1. 封装得太狠了!无论客户得需求什么,都是采用最高配置,这相当于你去配电脑,无论是什么需求,商家都会给你配最贵的电脑!
  • 针对封装得太狠了的问题,修改代码如下:
    • 针对于不同需求,我们需要创建不同的建造者,来分别生产不同
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 getMemory() {
        return memory;
    }

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

    public String getHd() {
        return hd;
    }

    public void setHd(String hd) {
        this.hd = hd;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", gpu='" + gpu + '\'' +
                ", memory='" + memory + '\'' +
                ", hd='" + hd + '\'' +
                '}';
    }
}
//高配
class AdvancedComputerBuilder {

    private Computer computer = new Computer();

    public Computer build() {
        computer.setCpu("i7 8750HK");
        computer.setGpu("rtx2080Ti");
        computer.setMemory("32g");
        computer.setHd("500g固态+2T机械");
        return computer;
    }
}

//中配
class MiddleComputerBuilder {

    private Computer computer = new Computer();

    public Computer build() {
        computer.setCpu("i7 7700hq");
        computer.setGpu("gtx1060");
        computer.setMemory("16g");
        computer.setHd("250g固态+1T机械");
        return computer;
    }
}

//低配
class LowComputerBuilder {

    private Computer computer = new Computer();

    public Computer build() {
        computer.setCpu("i7 7500u");
        computer.setGpu("gtx940mx");
        computer.setMemory("8g");
        computer.setHd("1T机械");
        return computer;
    }
}

//=======================时空线=============================
//=========上面为服务端(提供服务,作者),下面为客户端(使用服务)=====
public class AppTest {

    public static void main(String[] args) {

        AdvancedComputerBuilder adc = new AdvancedComputerBuilder();
        MiddleComputerBuilder mcb = new MiddleComputerBuilder();
        LowComputerBuilder lcb = new LowComputerBuilder();

        //玩游戏
        Computer c = adc.build();
        System.out.println(c);

        //开发
        Computer c2 = mcb.build();
        System.out.println(c2);

        //办公娱乐
        Computer c3 = mcb.build();
        System.out.println(c3);


    }
}
  • 这任然不是建造者模式:
    • 优点:
      1. 可以根据客户端的不同需求, 使用不同的建造者来生产产品
    • 缺点:
      1. 我们发现,多个不同的建造者中的代码,在重复!既然代码中出现了重复的代码,那就有了"坏味道"!
      2. 建造的过程不稳定! 如果在某个建造者创建产品的过程中,漏调了某一步,编译器也不会报错!
        (相当于,KFC的某一家分店,你制作汉堡包的流程突然少了某一步骤,出现的汉堡包味道就变了,因为没有标准!)
  • 针对以上两个问题,修改代码如下:
  • 创建一个建造者接口,把制作产品的具体步骤,稳定下来!
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 getMemory() {
        return memory;
    }

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

    public String getHd() {
        return hd;
    }

    public void setHd(String hd) {
        this.hd = hd;
    }

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

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

// 电脑建造者,建造者类,必须关联电脑产品

//高配
class AdvancedComputerBuilder implements ComputerBuilder{

    private Computer computer = new Computer();

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

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

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

    @Override
    public void setHd() {
        computer.setHd("500g固态+2T机械");
    }

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

//中配
class MiddleComputerBuilder implements ComputerBuilder{

    private Computer computer = new Computer();

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

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

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

    @Override
    public void setHd() {
        computer.setHd("250g固态+1T机械");
    }

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

//低配
class LowComputerBuilder implements ComputerBuilder{

    private Computer computer = new Computer();

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

    }

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

    }

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

    }

    @Override
    public void setHd() {
        computer.setHd("1T机械");
    }

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

//=======================时空线=============================
//=========上面为服务端(提供服务,作者),下面为客户端(使用服务)=====

//玩游戏
        AdvancedComputerBuilder acb = new AdvancedComputerBuilder();
        acb.setCpu();
        acb.setGpu();
        acb.setMemory();
        acb.setHd();
        Computer c = acb.build();
        System.out.println(c);

        //开发
        MiddleComputerBuilder mcb = new MiddleComputerBuilder();
        mcb.setCpu();
        mcb.setGpu();
        mcb.setMemory();
        mcb.setHd();
        Computer c2 = mcb.build();
        System.out.println(c2);

        //办公娱乐
        LowComputerBuilder lcb = new LowComputerBuilder();
        lcb.setCpu();
        lcb.setGpu();
        lcb.setMemory();
        lcb.setHd();
        Computer c3 = lcb.build();
        System.out.println(c3);
  • 这还不是建造者模式
    • 优点:
      1. 建造者类中的建造过程是稳定的,不会漏掉某一步!!这样当客户端想扩展建造者时,也不会漏掉某一步
    • 缺点:
      1. 代码任然有重复
      2. 客户端现在又变成了客户端自己配置电脑,又违反了迪米特法则
        (这相当于,去电脑城配电脑,虽然不用你亲自组装电脑,但是你必须"指挥"装机老板,该装什么…该装什么…)
  • 针对代码重复,和违反迪米特法则,修改代码如下:
  • 建造者模式: 终于进化出来了
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 getMemory() {
        return memory;
    }

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

    public String getHd() {
        return hd;
    }

    public void setHd(String hd) {
        this.hd = hd;
    }

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

//稳点建造过程
interface ComputerBuilder {
    public void setCpu();
    public void setGpu();
    public void setMemory();
    public void setHd();
    public Computer build();
}

//高配
class AdvancedComputerBuilder implements ComputerBuilder {

    private Computer computer = new Computer();

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

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

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

    @Override
    public void setHd() {
        computer.setHd("500g固态+2T机械");
    }

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

//中配
class MiddleComputerBuilder implements ComputerBuilder {

    private Computer computer = new Computer();

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

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

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

    @Override
    public void setHd() {
        computer.setHd("250g固态+1T机械");
    }

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

//低配
class LowComputerBuilder implements ComputerBuilder {

    private Computer computer = new Computer();

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

    }

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

    }

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

    }

    @Override
    public void setHd() {
        computer.setHd("1T机械");
    }

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

//指挥者 指挥的过程,从客户端分离出来
class Director {

    public Computer build(ComputerBuilder cb) {
        cb.setCpu();
        cb.setGpu();
        cb.setMemory();
        cb.setHd();

        return cb.build();
    }
}

//=======================时空线=============================
//=========上面为服务端(提供服务,作者),下面为客户端(使用服务)=====

public class AppTest {

    public static void main(String[] args) {




        AdvancedComputerBuilder acb = new AdvancedComputerBuilder();
        MiddleComputerBuilder mcb = new MiddleComputerBuilder();
        LowComputerBuilder lcb = new LowComputerBuilder();

        Director director = new Director();

        //玩游戏
        Computer c = director.build(acb);
        System.out.println(c);

        //开发
        Computer c2 = director.build(mcb);
        System.out.println(c2);

        //办公娱乐
        Computer c3 = director.build(lcb);
        System.out.println(c3);

        MiddleHighComputerBuilder mhcb = new MiddleHighComputerBuilder();
        Computer c4 = director.build(mhcb);
        System.out.println(c4);

    }
}
  • 这就是建造者模式
    • 即
      1. 一个稳点建造过程的接口
      2. 建造者实现建造过程的接口
      3. 创建一个指挥者,把过程交给指挥者就行了
    • 优点:
      1. 创建对象的工厂是稳定不变的(因为有ComputerBuilder接口来稳定过程)
      2. 创建对象的过程只写了一次,没有重复代码(指挥者完成)
      3. 当需要扩展指挥者的时候,不用修改之前的代码,这符合开闭原则

在这里插入图片描述

建造者与工厂模式的区别:
  • 工厂模式:
    • 工厂模式只需要一个简单的new,new出产品即可.
  • 建造者模式:
    • 建造者更注重在new出产品之后的,为产品属性赋值的过程!
三浪.
关注
专栏目录
Java设计模式之建造者模式实例详解
08-29
"Java设计模式之建造者模式实例详解" 本文主要介绍了Java设计模式之建造者模式，结合具体实例形式分析了建造者模式的概念、原理、实现方法与相关使用注意事项。 建造者模式的概念 建造者模式（Builder Pattern）...
设计模式之——建造者模式
m0_37914588的博客
01-08 2304
一、基本介绍 建造者模式（创建型）：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。 二、包含角色 1.指挥者：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，即构建搭建步骤。 2.产品角色：包含多个组成部件的复...
设计模式之建造者模式详解
猫猫爱吃小鱼粮
03-25 1235
设计模式之建造者模式详解
C++ 设计模式之建造者模式
K1_uestc的博客
01-09 1099
每个组件可能有不同的型号、配置和制造，这个时候计算机就可以被视为⼀个复杂对象，构建过程相对复杂，⽽我们使⽤建造者模式将计算机的构建过程封装在⼀个具体的建造者类中，⽽指导者类则负责指导构建的步骤和顺序。同时有⼀个指导者类负责协调建造者的⼯作，按照⼀定的顺序或逻辑来执⾏构建步骤，最终⽣成产品。对应的，建造者模式适⽤于复杂对象的创建，当对象构建过程相对复杂时可以考虑使⽤建造者模式，但是当产品的构建过程发⽣变化时，可能需要同时修改指导类和建造者类，这就使得重构变得相对困难。
java设计模式之建造者模式
J_Newbie的博客
09-09 1067
java设计模式之建造者模式
设计模式——建造者模式
weixin_46073538的博客
07-10 1118
建造者模式(Builder Pattern)又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别)，使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们.用户不需要知道内部的具体构建细节。
23种设计模式之建造者模式
JAVA开发区的博客
04-28 1231
将一个复杂对象的构造与它的表示分离，使同样的建造过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是一个负责的对象分解为多个简单的对象，然后一步步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
Java设计模式——建造者模式
2302_77758423的博客
06-03 1348
建造者模式是一种强大的工具，可以帮助我们更好地组织和管理复杂对象的创建过程。通过将对象的构建过程与其表示分离，我们可以更灵活地控制对象的创建，并提高代码的可读性和可维护性。
设计模式之建造者模式(含链式调用)
qq_40514744的博客
12-13 1282
开始之前 大家都知道建造者模式是23种设计模式之一，其属于创建型模式，我们可以先看一下菜鸟教程对建造者模式的介绍。 建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 意图 将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 主要解决 需要解决的问题灵活性要求较高，无需在意建造过程中内部细节可使用此模式。 类图 建造者角色 Product（产品类）：需要生成的目标对
Java设计模式：建造者模式
Java技术一点通
03-08 1308
建造者模式（Builder Pattern）是一种创建型设计模式，旨在将一个复杂对象的构建与表现分离，使得同样的构建过程可以创建不同的表示。用户只需要指定需要建造的类型就可以得到该类型对应的产品实例，不必关心建造的过程细节，建造者模式就是如何逐步构建包含多个组件的对象，相同的构建过程可以创建不同的产品。
JavaScript设计模式之建造者模式实例教程
01-19
本文实例讲述了JavaScript设计模式之建造者模式。分享给大家供大家参考，具体如下： 一、建造者模式模式概念 建造者模式可以将一个复杂的对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。也就是说...
Java创建型设计模式之建造者模式详解.rar
07-10
建造者模式是软件设计模式中的一种，属于创建型模式，它的主要目的是将对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。在Java中，建造者模式经常用于构造复杂对象，通过一步一步地创建对象，使得...
LabVIEW提高开发效率技巧----调度器设计模式
最新发布
bjcyck的博客
10-04 1036
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
行为设计模式 -模板方法模式- JAVA
智的博客
09-28 1847
模板方法是一种行为设计模式。模板方法设计模式用于创建方法存根并将某些实现步骤推迟到子类。模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构**的情况下，重新定义算法中的某些步骤。在面向对象程序设计过程中，我们常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。通俗理解，就是设计构建一个对象的时候，类的步骤已经固定了，可是某些类的实现逻辑。
【Java】六大设计原则和23种设计模式
weixin_71491685的博客
09-28 1422
代理模式给某一个对象提供一个代理对象并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。
设计模式之访问者模式
一个老Java开发的自白
10-02 1215
访问者模式是一种强大的设计模式，它通过将数据结构与数据操作分离，使得系统更加灵活和可扩展。然而，它也有一些缺点，如增加新的数据结构困难、破坏封装等。因此，在使用访问者模式时，需要权衡其优缺点，并根据具体的应用场景进行选择。 在实际开发中，访问者模式通常适用于需要对一个对象结构中的对象进行很多不同并且不相关的操作的场景。在这些情况下，使用访问者模式可以避免让这些操作“污染”这些对象的类，从而保持代码的清晰和简洁。
设计模式-适配器模式
ZSS1753936255的博客
10-02 325
这段代码就是在适配器Adapter中关联了适配器适配器母接口Speker. 在适配器中的translate中实现了 speaker.speak()方法。首先：如何调用被适配的对象呢？可以通过 关联或者继承 适配器来实现。（1：这段代码是通过是通过继承来实现的，也达到了接口转换的目的）适配器模式：将一类的接口转换成满足用户需求的另一种接口。是的不相容的接口得以共同工作。2:通过对象关联的方法来实现适配器，就是上述的UML类图保持一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值