建造者模式_建造者模式使用场景 - CSDN
精华内容
参与话题
  • 前言今天我来全面总结一下Android开发中最常用的设计模式 -建造者模式。 其他设计模式介绍 1分钟全面了解“设计模式” 单例模式(Singleton) - 最易懂的设计模式解析 简单工厂模式(SimpleFactoryPattern)-...

    前言

    今天我来全面总结一下Android开发中最常用的设计模式 -建造者模式。

    其他设计模式介绍
    1分钟全面了解“设计模式”
    单例模式(Singleton) - 最易懂的设计模式解析
    简单工厂模式(SimpleFactoryPattern)- 最易懂的设计模式解析
    工厂方法模式(Factory Method)- 最易懂的设计模式解析
    抽象工厂模式(Abstract Factory)- 最易懂的设计模式解析
    策略模式(Strategy Pattern)- 最易懂的设计模式解析
    适配器模式(Adapter Pattern)- 最易懂的设计模式解析
    代理模式(Proxy Pattern)- 最易懂的设计模式解析
    模板方法模式(Template Method) - 最易懂的设计模式解析
    建造者模式(Builder Pattern)- 最易懂的设计模式解析
    外观模式(Facade Pattern) - 最易懂的设计模式解析


    目录

    建造者模式.jpg


    #1. 介绍

    1.1 定义

    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

    1.2 主要作用

    在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。

    1. 用户只需要给出指定复杂对象的类型和内容;
    2. 建造者模式负责按顺序创建复杂对象(把内部的建造过程和细节隐藏起来)

    1.3 解决的问题

    • 方便用户创建复杂的对象(不需要知道实现过程)
    • 代码复用性 & 封装性(将对象构建过程和细节进行封装 & 复用)

    例子:造汽车 & 买汽车。

    1. 工厂(建造者模式):负责制造汽车(组装过程和细节在工厂内)
    2. 汽车购买者(用户):你只需要说出你需要的型号(对象的类型和内容),然后直接购买就可以使用了
      (不需要知道汽车是怎么组装的(车轮、车门、发动机、方向盘等等))

    2. 模式原理

    2.1 UML类图 & 组成

    UML类图

    模式讲解:

    1. 指挥者(Director)直接和客户(Client)进行需求沟通;
    2. 沟通后指挥者将客户创建产品的需求划分为各个部件的建造请求(Builder);
    3. 将各个部件的建造请求委派到具体的建造者(ConcreteBuilder);
    4. 各个具体建造者负责进行产品部件的构建;
    5. 最终构建成具体产品(Product)。

    2.2 实例讲解

    接下来我用一个实例来对建造者模式进行更深一步的介绍。

    a. 实例概况

    • 背景:小成希望去电脑城买一台组装的台式主机
    • 过程:
      1. 电脑城老板(Diretor)和小成(Client)进行需求沟通(买来打游戏?学习?看片?)
      2. 了解需求后,电脑城老板将小成需要的主机划分为各个部件(Builder)的建造请求(CPU、主板blabla)
    1. 指挥装机人员(ConcreteBuilder)去构建组件;
    2. 将组件组装起来成小成需要的电脑(Product)

    b. 使用步骤
    步骤1: 定义组装的过程(Builder):组装电脑的过程

    
    public  abstract class Builder {  
    
    //第一步:装CPU
    //声明为抽象方法,具体由子类实现 
        public abstract void  BuildCPU();
    
    //第二步:装主板
    //声明为抽象方法,具体由子类实现 
        public abstract void BuildMainboard();
    
    //第三步:装硬盘
    //声明为抽象方法,具体由子类实现 
        public abstract void BuildHD();
    
    //返回产品的方法:获得组装好的电脑
        public abstract Computer GetComputer();
    }
    

    步骤2: 电脑城老板委派任务给装机人员(Director)

    public class Director{
                            //指挥装机人员组装电脑
                            public void Construct(Builder builder){
                                    
                                     builder. BuildCPU();
                                     builder.BuildMainboard();
                                     builder. BuildHD();
                                  }
     }
    
    
    

    步骤3:创建具体的建造者(ConcreteBuilder):装机人员

    //装机人员1
      public class ConcreteBuilder extend  Builder{
        //创建产品实例
        Computer computer = new Computer();
    
        //组装产品
        @Override
        public void  BuildCPU(){  
           computer.Add("组装CPU")
        }  
    
        @Override
        public void  BuildMainboard(){  
           computer.Add("组装主板")
        }  
    
        @Override
        public void  BuildHD(){  
           computer.Add("组装主板")
        }  
    
        //返回组装成功的电脑
         @Override
          public  Computer GetComputer(){  
          return computer
        }  
    }
    
    

    步骤4:定义具体产品类(Product):电脑

    public class Computer{
        
        //电脑组件的集合
        private List<String> parts = new ArrayList<String>();
         
        //用于将组件组装到电脑里
        public void Add(String part){
        parts.add(part);
    }
        
        public void Show(){
              for (int i = 0;i<parts.size();i++){    
              System.out.println(“组件”+parts.get(i)+“装好了”);
              }
              System.out.println(“电脑组装完成,请验收”);
              
     
    }
    
    }
    

    步骤5:客户端调用-小成到电脑城找老板买电脑

    
    public class Builder Pattern{
      public static void main(String[] args){
    
    //逛了很久终于发现一家合适的电脑店
    //找到该店的老板和装机人员
      Director director = new Director();
      Builder builder = new ConcreteBuilder();
    
    //沟通需求后,老板叫装机人员去装电脑
    director.Construct(builder);
    
    //装完后,组装人员搬来组装好的电脑
    Computer computer = builder.GetComputer();
    //组装人员展示电脑给小成看
    computer.Show();
    
        }
            
    }
       
    

    结果输出

    组件CUP装好了
    组件主板装好了
    组件硬盘装好了
    电脑组装完成,请验收
    

    通过上述这个常见的生活例子,我相信你已经完全明白了建造者模式的原理了!!


    3. 优缺点

    在全面解析完后,我来分析下其优缺点:

    3.1 优点

    • 易于解耦
      将产品本身与产品创建过程进行解耦,可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
    • 易于精确控制对象的创建
      将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰
    • 易于拓展
      增加新的具体建造者无需修改原有类库的代码,易于拓展,符合“开闭原则“。

    每一个具体建造者都相对独立,而与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者,用户使用不同的具体建造者即可得到不同的产品对象。

    3.2 缺点

    • 建造者模式所创建的产品一般具有较多的共同点,其组成部分相似;如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。
    • 如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大。

    4. 应用场景

    • 需要生成的产品对象有复杂的内部结构,这些产品对象具备共性;
    • 隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同的产品。

    5. 总结

    • 本文主要对建造者模式进行了全面介绍
    • 接下来将介绍其他设计模式,感兴趣的同学可以继续关注carson_ho的微信公众号
      示意图
      示意图

    请帮顶 / 评论点赞!因为你的鼓励是我写作的最大动力!

    相关文章阅读
    单例模式(Singleton) - 最易懂的设计模式解析
    简单工厂模式(SimpleFactoryPattern)- 最易懂的设计模式解析
    工厂方法模式(Factory Method)- 最易懂的设计模式解析
    抽象工厂模式(Abstract Factory)- 最易懂的设计模式解析
    策略模式(Strategy Pattern)- 最易懂的设计模式解析
    适配器模式(Adapter Pattern)- 最易懂的设计模式解析
    代理模式(Proxy Pattern)- 最易懂的设计模式解析
    模板方法模式(Template Method) - 最易懂的设计模式解析
    建造者模式(Builder Pattern)- 最易懂的设计模式解析
    外观模式(Facade Pattern) - 最易懂的设计模式解析

    展开全文
  • 设计模式:建造者模式(Builder)

    千次阅读 2020-04-23 18:08:01
    建造者模式:是将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。  建造者模式通常包括下几个角色: 1. builder(抽象建造者):给出一个抽象结论,以规范产品对象的各个组成成分的...

    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。


    欢迎跳转到本文的原文链接:https://honeypps.com/design_pattern/builder/

    建造者模式:是将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
    这里写图片描述

     建造者模式通常包括下几个角色:

    1. builder(抽象建造者):给出一个抽象结论,以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的那些部分的创建,并不涉及具体的对象部件的创建。
    2. ConcreteBuilder(具体建造者):实现Builder接口,针对不同的商业逻辑,具体化复杂对象的各部分的创建。在构造过程完成后,提供产品的实例。
    3. Director(指导者):调用具体建造者来创建复杂对象的各个部分,在指导者中不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。
    4. Product(产品类):要创建的复杂对象。

    举个简单例子(车的建造过程,包括造轮子,造发动机和造车身结构):
    1 产品类

    public class Car
    {
        private String wheel;
        private String skeleton;
        private String engine;
    // 省略getter和setter方法
    }
    

    2 抽象建造者

    public interface ICarBuilder
    {
        public void buildWheel();
        public void buildSkeleton();
        public void buildEngine();
    
        Car buildCar();
    }
    

    3 具体建造者

    public class ConcreteBuilder implements ICarBuilder
    {
        Car car;
    
        public ConcreteBuilder()
        {
            car = new Car();
        }
    
        @Override
        public void buildWheel()
        {
            car.setWheel("轮子");
        }
    
        @Override
        public void buildSkeleton()
        {
            car.setSkeleton("车身结构");
        }
    
        @Override
        public void buildEngine()
        {
            car.setEngine("发动机");
        }
    
        @Override
        public Car buildCar()
        {
            return this.car;
        }
    }
    

    4 指导者

    public class CarDirector
    {
        public Car constructCar(ICarBuilder builder)
        {
            builder.buildEngine();
            builder.buildSkeleton();
            builder.buildWheel();
            return builder.buildCar();
        }
    }
    

    5 测试代码

    public class MainTest
    {
        public static void main(String[] args)
        {
            CarDirector director = new CarDirector();
            Car car = director.constructCar(new ConcreteBuilder());
            System.out.println(car.getWheel());
            System.out.println(car.getEngine());
            System.out.println(car.getSkeleton());
        }
    }
    

    适用场景

    1. 需要生产的产品对象有复杂的内部结构。
    2. 需要生产的产品对象的属性相互依赖,建造者模式可以强迫生成顺序。
    3. 在对象创建过程中会使用到系统中的一些其它对象,这些对象在产品对象的创建过程中不易得到。

    优点

    1. 使用建造者模式可以使客户端不必知道产品内部的组成细节。(封装性)
    2. 具体的建造者之间是相互独立的,对系统的扩展非常有利。(扩展性)
    3. 由于具体的建造者是独立的,因此可以对建造过程逐步细化,而不对其他模块产生任何影响。

    与抽象工厂的区别:在建造者模式里,有个指导者,由指导者来管理建造者,用户是与指导者联系的,指导者联系建造者最后得到产品。即建造模式可以强制实行一种分步骤进行的构造过程。工厂模式是将对象的全部创建过程封装在工厂类中,由工厂类想客户端提供最终的产品。而在建造者模式中,建造者类一般只提供产品类中各个组件的建造,而将具体建造过程交付给指导者,由指导者负责将各个组件按照特定的规则组建为产品,然后将组建好的产品交付给客户端。

    Jdk中的建造者模式

    1. java.lang.StringBuilder#append()
    2. java.lang.StringBuffer#append()
      3.java.sql.PreparedStatement

    参考资料:

    1. 23种设计模式
    2. 细数JDK里的设计模式

    欢迎跳转到本文的原文链接:https://honeypps.com/design_pattern/builder/

    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。


    展开全文
  • 设计模式之建造者模式(十)

    千次阅读 2018-03-19 14:27:38
    建造者模式简介 建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 一个 Builder 类会一步一步构造最终的对象...

    建造者模式

    简介

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

        一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

    类图

    实现方式

        以我们的最常用的电脑为例,电脑是一个抽象的概念,但是具体型号组装好的电脑就是一个个实体。我们组装电脑就是一个复杂对象的创建过程,电脑包括了CPU,主板,内存,硬盘等重要的部件。这些部件都是缺一不可的,无论缺少那个电脑都是不正常的。

     

    使用抽象类定义电脑的重要部件,这里只列举场景的重要部件,独显什么的先不考虑

    package com.rabbit.pattern.builder;
    
    /**
     * 抽象电脑类
     * Created by vip on 2018/3/19.
     */
    public abstract class AbstractComputer {
    
        //显示器
        public abstract void display();
        //CPU
        public abstract void cpu();
        //内存条
        public abstract void memory();
        //硬盘
        public abstract void disk();
        //主板
        public abstract void mainboard();
        //键盘
        public abstract void keyboard();
        //鼠标
        public abstract void mouse();
        //机箱
        public abstract void crate();
    
    }
    

    电脑的抽象定义出来了,接下来就要定义具体的组装

    package com.rabbit.pattern.builder;
    
    /**
     * 联想天逸510Pro电脑配置
     * Created by vip on 2018/3/19.
     */
    public class TianYiComputer extends AbstractComputer {
        @Override
        public void display() {
            System.out.println("联想23英寸超大屏幕");
        }
    
        @Override
        public void cpu() {
            System.out.println("Intel Core I5-7400,三级缓存6MB,4核,3.00GHz");
        }
    
        @Override
        public void memory() {
            System.out.println("DDR4 8G内存,最大扩容到32G");
        }
    
        @Override
        public void disk() {
            System.out.println("1TB超大容量内存,转速7200转/分钟");
        }
    
        @Override
        public void mainboard() {
            System.out.println("因特尔主板");
        }
    
        @Override
        public void keyboard() {
            System.out.println("联想无线键盘");
        }
    
        @Override
        public void mouse() {
            System.out.println("联想无线鼠标");
        }
    
        @Override
        public void crate() {
            System.out.println("联想自主研发ideacentre机箱");
        }
    }
    

    联系天逸510Pro电脑已经定义好了,接下来就是对象的创建问题。正常的创建过程

    package com.rabbit.pattern.builder;
    
    /**
     * Created by vip on 2018/3/19.
     */
    public class Demo {
    
        public static void main(String[] args) {
            //电脑创建好了
            AbstractComputer ac = new TianYiComputer();
            //组装
            ac.mouse();
            ac.memory();
            ac.disk();
        }
    
    }
    

    运行结果:

    问题:这样组装出来的电脑万一那个用户用了不是问题大了吗?只有鼠标,内存,和硬盘就说组装好了电脑。那么应该如何规范这个对象的创建呢?
    
    这个就是建造者模式的好处,可以将复杂对象的创建和具体开来。那我们就需要添加一个指挥者类,用于构建复杂对象。
    
    package com.rabbit.pattern.builder;
    
    /**
     * 负责调度创建AbstarctComputer的具体对象
     * Created by vip on 2018/3/19.
     */
    public class ComputerDirector {
    
        private AbstractComputer ac;
    
        public ComputerDirector(AbstractComputer ac) {
            this.ac = ac;
        }
    
        public void create() {
            //复杂对象的创建
            //电脑组装对象的创建这些都是必要的
            //总不能电脑组装少个CPu或者主板什么零件吧
            ac.cpu();
            ac.crate();
            ac.disk();
            ac.display();
            ac.keyboard();
            ac.mainboard();
            ac.memory();
            ac.mouse();
        }
    
    }
    

    通过指挥者帮助我们创建好实例

    package com.rabbit.pattern.builder;
    
    /**
     * Created by vip on 2018/3/19.
     */
    public class Demo {
    
        public static void main(String[] args) {
            new ComputerDirector(new TianYiComputer()).create();
        }
    
    }

    组装电脑结果,这样就可以避免由于那个零件没有组装而出现问题。可能会有人想说我可以把所有的方法都调用一遍,这样不是和指挥者类一样吗?建造者模式的出现就是为了避免复杂对象的创建过程出现其他问题而出现的,指挥者可以指定对象如何创建。这里只是简单的介绍建造者模式的具体思想和简单案例,具体到项目中还需要自己去思考理解透对应的模式才可以应对各种情况。

     

    总结

    使用场景

    1、需要生成的对象具有复杂的内部结构。

    2、需要生成的对象内部属性本身相互依赖。

    优点

    1、建造者独立,易扩展。

    2、便于控制细节风险。

    缺点

     1、产品必须有共同点,范围有限制。

    2、如内部变化复杂,会有很多的建造类。

    展开全文
  • 23种设计模式(4):建造者模式

    万次阅读 多人点赞 2012-07-10 17:50:20
    定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 类型:创建类模式 类图: 四个要素 ...产品类:一般是一个较为复杂的对象,也就是说...抽象建造者:引入抽象建造者的目的,是
    定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
    

    类型:创建类模式

    类图:

    四个要素

    • 产品类:一般是一个较为复杂的对象,也就是说创建对象的过程比较复杂,一般会有比较多的代码量。在本类图中,产品类是一个具体的类,而非抽象类。实际编程中,产品类可以是由一个抽象类与它的不同实现组成,也可以是由多个抽象类与他们的实现组成。
    • 抽象建造者:引入抽象建造者的目的,是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法,一个用来建造产品,一个是用来返回产品。
    • 建造者:实现抽象类的所有未实现的方法,具体来说一般是两项任务:组建产品;返回组建好的产品。
    • 导演类:负责调用适当的建造者来组建产品,导演类一般不与产品类发生依赖关系,与导演类直接交互的是建造者类。一般来说,导演类被用来封装程序中易变的部分。

    代码实现

    class Product {
    	private String name;
    	private String type;
    	public void showProduct(){
    		System.out.println("名称:"+name);
    		System.out.println("型号:"+type);
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public void setType(String type) {
    		this.type = type;
    	}
    }
    
    abstract class Builder {
    	public abstract void setPart(String arg1, String arg2);
    	public abstract Product getProduct();
    }
    class ConcreteBuilder extends Builder {
    	private Product product = new Product();
    	
    	public Product getProduct() {
    		return product;
    	}
    
    	public void setPart(String arg1, String arg2) {
    		product.setName(arg1);
    		product.setType(arg2);
    	}
    }
    
    public class Director {
    	private Builder builder = new ConcreteBuilder();
    	public Product getAProduct(){
    		builder.setPart("宝马汽车","X7");
    		return builder.getProduct();
    	}
    	public Product getBProduct(){
    		builder.setPart("奥迪汽车","Q5");
    		return builder.getProduct();
    	}
    }
    public class Client {
    	public static void main(String[] args){
    		Director director = new Director();
    		Product product1 = director.getAProduct();
    		product1.showProduct();
    
    		Product product2 = director.getBProduct();
    		product2.showProduct();
    	}
    }
    

    建造者模式的优点

            首先,建造者模式的封装性很好。使用建造者模式可以有效的封装变化,在使用建造者模式的场景中,一般产品类和建造者类是比较稳定的,因此,将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。

            其次,建造者模式很容易进行扩展。如果有新的需求,通过实现一个新的建造者类就可以完成,基本上不用修改之前已经测试通过的代码,因此也就不会对原有功能引入风险。

     

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

           我们可以看到,建造者模式与工厂模式是极为相似的,总体上,建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中,假如把这个导演类看做是最终调用的客户端,那么图中剩余的部分就可以看作是一个简单的工厂模式了。

           与工厂模式相比,建造者模式一般用来创建更为复杂的对象,因为对象的创建过程更为复杂,因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说,工厂模式是将对象的全部创建过程封装在工厂类中,由工厂类向客户端提供最终的产品;而建造者模式中,建造者类一般只提供产品类中各个组件的建造,而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品,然后将组建好的产品交付给客户端。

     

    总结

           建造者模式与工厂模式类似,他们都是建造者模式,适用的场景也很相似。一般来说,如果产品的建造很复杂,那么请用工厂模式;如果产品的建造更复杂,那么请用建造者模式。

    展开全文
  • 设计模式——建造者模式解析

    万次阅读 多人点赞 2017-08-26 14:16:08
    1. 建造者模式介绍建造者模式定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 建造者模式包括的角色:(1)Builder:给出一个抽象接口或抽象类,以规范产品的建造。这个接口...
  • 创造型模式 - 建造者模式

    千次阅读 2015-07-21 22:42:15
    建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。Separate the construction of a complex object from its representation so that the same construction process can ...
  • 建造者模式

    2020-10-24 21:12:03
    经典的建造者模式一般有Product、Builder、ConcreteBuilder、Director几个角色,由Director按照不同的规则建造具体的Product;现在常见的建造者模式一般只有Product和Builder两个角色,通过链式调用来产生不同的...
  • 建造者模式应用场景

    千次阅读 2019-06-11 17:04:38
    建造者模式建造者模式,又称构建者模式,将一部负责对象的构建分为许多小对象的构建,最后在整合构建的模式。  构建者模式一般用在构建流程或者组成部件固定的场合,将这些部件分开构建成为组件对象,再将...
  • 有抽象建造者2.2. 无抽象建造者3. 应用3.1. 复杂对象构建举例3.2. 多参数方法改良举例3.3. JDK:Locale3.4. JDK:StringBuilder3.5. Gson:GsonBuilder3.6. OkHttp:OkHttpClient.Builder4. 特点4.1. 优势4.2. 缺点...
  • 建造者模式详解 (附java语言源码)

    千次阅读 2019-05-29 11:03:01
    建造者模式(Builder Pattern): 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。(Separate the construction of a complex object from its representation so that the same ...
  • 就像是生产人偶,这些人偶有两脚、两手、头、身体,在生产过程中,这些部位是一定要的且生产这些部位的顺序一致,只不过头有大头和小头,身体有胖和瘦的区别,那么这个时候,就可以使用建造者模式。 二、问题 以...
  • 深入理解建造者模式 ——组装复杂的实例

    万次阅读 多人点赞 2018-06-03 17:33:32
    1 建造者模式介绍 1.1 建造者模式定义 1.2 为什么要用建造者模式(优点)? 1.3 哪些情况不要用建造者模式(缺点)? 1.4 建造者模式与工厂模式的区别 1 建造者模式介绍 1.1 建造者模式定义 建造者模式...
  • java设计模式之建造者模式

    万次阅读 多人点赞 2015-04-12 08:03:22
    本文属于23种设计模式系列。 介绍的是建造者模式
  • 设计模式之建造者模式(创建型模式)

    万次阅读 2020-05-06 15:53:59
    前言
  • python设计模式03-建造者模式

    万次阅读 2018-09-24 09:57:28
    建造者模式对比工厂模式 建造者模式对比工厂模式两者之间的差别并不明确,主要的区别在于工厂模式以单个步骤创建对象,而建造者模式以多个步骤创建对象,并且几乎始终会使用一个指挥者。另外一个区别是,在工厂模式...
  • 复杂对象的组装与创建——建造者模式(一)

    万次阅读 多人点赞 2012-04-10 09:15:12
    如何将这些部件组装成一辆完整的汽车并返回给用户,这是建造者模式需要解决的问题。建造者模式又称为生成器模式,它是一种较为复杂、使用频率也相对较低的创建型模式。建造者模式为客户端返回的不是一个简单的产品,...
  • 【4】设计模式-建造者模式

    万次阅读 2019-12-03 21:06:56
    知识点1:什么是建造者模式 知识点2:建造者应用场景 知识点3:实际案例 1、建立一个人物对象Person 2、建立Builder接口 3、创建实现类:ConcreteBuilder 4、创建Director 知识点1:什么是建造者模式 建造者...
  • 设计模式之建造者模式

    万次阅读 2015-08-31 16:20:51
    建造者模式(Builder Pattern):将一个复杂对象(产品)的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。也被称为生成器模式。 建造者模式是复杂对象的组装和创建,是一种对象创建型模式,满足依赖...
  • java建造者模式--给一个你一看就懂的建造者模式

    万次阅读 多人点赞 2018-11-22 15:51:36
    在开始写这个建造者模式的文章前,我也确实看了挺多次其他介绍这个模式的文章。感觉看了很多次才有一点对建造者模式明白透彻的感觉。细心想来,可能是接口的理解不好,平时工作比较少用到过建造者模式,所以理解的...
  • 建造者模式适用于一个对象的内部有特别多的属性需要外部来传递的情况,这些属性需要调用方动态的传递。所以Builder(建造者)模式是一个包含了很多个零件的对象,它封装了如何操作这些零件创造出最终调用方想要的...
1 2 3 4 5 ... 20
收藏数 53,329
精华内容 21,331
关键字:

建造者模式