精华内容
下载资源
问答
  • 2017-04-17 18:03:56

    一般在封装实体类时我们通常会用构造方法等形式往实体类传递参数,有可能对不同个数的参数进行初始化,你会定义出不同的构造方法,当然这都没问题,如果是当前实体类中的参数过于多时,这时候再用构造方法传递参数会有点力不从心,很大程度上会影响代码的可读性与美观性。那这个时候构造者模式的出现完美的解决这一问题。

    构造者模式的出现很好的解决了多参数初始化的问题。我简单写个例子用来构造一个网络请求地址的实体类,带大家简单了解下什么是构造者模式

     

    
    /**
     * Created by xiedong on 2017/4/17.
     */
    
    public class ParamsBuilder {
        private String url;
        private String password;
        private String username;
    
        public String getUrl() {
            return url;
        }
    
        public String getPassword() {
            return password;
        }
    
        public String getUsername() {
            return username;
        }
    
    
        public static class Builder {
            private String url = null;
            private String password = null;
            private String username = null;
    
            public Builder url(String url) {
                this.url = url;
                return this;
            }
    
            public Builder username(String username) {
                this.username = username;
                return this;
            }
    
            public Builder password(String password) {
                this.password = password;
                return this;
            }
    
            public ParamsBuilder builder() {
                return new ParamsBuilder(this);
            }
        }
    
    
        private ParamsBuilder(Builder b) {
            url = b.url;
            password = b.password;
            username = b.username;
        }
    
    
        @Override
        public String toString() {
            return "ParamsBuilder " + url + "/?username=" + username + "?password=" + password;
        }
    }
    


    初始化的时候

    ParamsBuilder params = new ParamsBuilder.Builder()
                    .url("wwww.baidu.com")
                    .username("xie")
                    .password("123")
                    .builder();

     

     

     

    更多相关内容
  • java_构造者模式

    2017-02-08 19:34:58
    本人用java写的构造者模式的小demo,源码里有详细的注释,保证一看就懂。欢迎交流指点。
  • 猜字游戏构造者

    2021-02-17 17:29:57
    猜字游戏构造者 指示 完成的游戏应满足以下条件: 完成的游戏应该能够使用查询者或提示npm包接收用户输入。 您的解决方案至少应包含三个文件: Letter.js:包含一个构造函数,即Letter。 此构造函数应能够显示...
  • java之构造者模式

    千次阅读 2019-05-19 01:18:02
    构造者模式,又称之为建造者模式 应用场景 当一个bean类重载了多个构造方法时,并且参数随机使用时,考虑使用构造者模式, 在springsercurity中设置拦截规则时,应用到了构造者模式 Demo package com.yunsuibi;...

    介绍:

    	构造者模式,又称之为建造者模式,建造者模式,单例模式以及工厂模式都属于创建型模式
    

    应用场景

    当一个bean类重载了多个构造方法时,并且参数随机使用时,考虑使用构造者模式,
    

    Demo

    package com.yunsuibi;
    
    public class User {
    	private final String firstName; // required
    	private final String lastName; // required
    	private final int age; // optional
    	private final String phone; // optional
    	private final String address; // optional
    
    	private User(UserBuilder builder) {
    		this.firstName = builder.firstName;
    		this.lastName = builder.lastName;
    		this.age = builder.age;
    		this.phone = builder.phone;
    		this.address = builder.address;
    	}
    
    	public String getFirstName() {
    		return firstName;
    	}
    
    	public String getLastName() {
    		return lastName;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public String getPhone() {
    		return phone;
    	}
    
    	public String getAddress() {
    		return address;
    	}
    
    	@Override
    	public String toString() {
    		return "User [firstName=" + firstName + ", lastName=" + lastName + ", age=" + age + ", phone=" + phone
    				+ ", address=" + address + "]";
    	}
    
    	public static class UserBuilder {
    		private final String firstName;
    		private final String lastName;
    		private int age;
    		private String phone;
    		private String address;
    
    		public UserBuilder(String firstName, String lastName) {
    			this.firstName = firstName;
    			this.lastName = lastName;
    		}
    
    		public UserBuilder age(int age) {
    			this.age = age;
    			return this;
    		}
    
    		public UserBuilder phone(String phone) {
    			this.phone = phone;
    			return this;
    		}
    
    		public UserBuilder address(String address) {
    			this.address = address;
    			return this;
    		}
    
    		public User build() {
    			return new User(this);
    		}
    
    	}
    }
    

    运行

    public static void main(String[] args) {
    		User build = new User.UserBuilder("Jhon", "Doe").address("北京").build();
    		System.out.println(build);
    		User build2 = new User.UserBuilder("李四", "哈哈").address("12").build();
    		System.out.println(build2);
    	}
    

    个人博客 百度搜索:云随笔

    可以关注下博主的公众号,实时推送解决方案!
    公众号

    展开全文
  • 建造模式是设计模式的一种,讲一个复杂对象的构建和他的表示分离,是的同样的构建过程可以创建不同的表示。 这种模式又称为生成器模式,这种类型的设计模式提供一种创建对象的最佳方式。 1、定义:将一个复杂...

    1. 概念

    建造者模式是设计模式的一种,讲一个复杂对象的构建和他的表示分离,是的同样的构建过程可以创建不同的表示。

    这种模式又称为生成器模式,这种类型的设计模式提供一种创建对象的最佳方式。

    1、定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示
    2、主要作用:在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
    3、如何使用:用户只需要给出指定复杂对象的类型和内容,建造者模式负责按顺序创建复杂对象(把内部的建造过程和细节隐藏起来)
    4、解决的问题
    (1)、方便用户创建复杂的对象(不需要知道实现过程)
    (2)、代码复用性 & 封装性(将对象构建过程和细节进行封装 & 复用)
    5、注意事项:与工厂模式的区别是:建造者模式更加关注与零件装配的顺序,一般用来创建更为复杂的对象

    2. lombok + builder 模式

    //带填坑

    3. 好处

    因为我们构建java bean 的时候,其实就有三种写法。

    1. 通过构造函数传参的方式来进行构建(臃肿 不能灵活地只设置某些参数)

    2.写很多构造方法。而且容易吧两个属性的参数写错位置等等;(重载很多的构造器,然后可以保证数据的一致性,比较安全)

    3.写一堆setter方法,缺点就是够早的过程会被分到几个调用中。构造可以出现不一致的状态。(而且代码很啰嗦)

    4.采用builder模式的话,当一个类的参数很多的时候。

    (使用javabean模式,调用一个无参的构造器,然后调用setter方法来设置每个必要的参数。但是javabean自身有着严重的缺点,因为构造过程被分到几个调用中,在构造javabean可能处于不一致的状态,类无法仅仅通过检验构造器参数的有效性来保证一致性。也就是set的过程中其实很多时候并不能保证一致性,因为set已经算是分开执行了)

    build模式 既能保证像重叠构造器那样的安全,也能实现JavaBean模式那样的可读性。 (不用操心线程)

     

    那么bulid模式的步骤:

    (1)不直接生成想要的对象,而是让客户端利用所有必要的参数调用构造器(或者静态工厂),得到一个build对象。 
    (2)然后让客户端在build对象上调用类似的setter方法来设置每个相关的可选参数, 
    (3)最后,客户端调用无参的build方法来生成不可变的对象。这个builder是它构建的静态成员类。
     

    上述有点难以理解,那么看看代码就好了~

    首先看一下我们自己的项目中的话,定义的不是足够规范的builder

    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class DemoBuilder implements Cloneable {
    
        private String imageBase64;
    
        public DemoBuilder buildImageBase64(String imageBase64) {
            this.setImageBase64(imageBase64);
            return this;
        }
        
        @Override
        public DemoBuilder clone() throws CloneNotSupportedException {
            return (DemoBuilder) super.clone();
        }
    }

    这是自己手写的 不够规范的builder~

    那么其实思想就是

    在构建这个对象的时候就可以用bulider模式~

    DemoBuilder demoBuilder = new DemoBuilder().buildImageBase64(""));

    类似这样来返回一个builder对象!

    但是这样写其实不规范,虽然思想是用链式的把参数一起放进去,setter中每个都返回this对象,

    最后应该给一个Bulid的构造函数来返回这个对象。

     

     

    参考:

    链接:https://www.jianshu.com/p/47329a94f5dc

    通过lombok带你读透Builder构建器:

    https://www.jianshu.com/p/0d8fc3df3647?from=timeline&isappinstalled=0

    展开全文
  • 对象性质的构造: 有些情况下,一个对象会有一些重要的性质,在它们没有恰当的值之前,对象不能作为一个完整的产品使用。比如,一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分,而在最起码的收件人...

    建造模式是对象的创建模式。建造模式可以将一个产品的内部对象与产品的生产过程分割开啦,从而可以使一个建造过程生成具有不同的内部表象的产品对象。
    对象性质的构造:
    有些情况下,一个对象会有一些重要的性质,在它们没有恰当的值之前,对象不能作为一个完整的产品使用。比如,一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分,而在最起码的收件人地址得到赋值之前,这个电子邮件不能发送。
    有些情况下,一个对象的一些性质必须按照某个顺序赋值才有意义。在某个性质没有赋值之前,另一个性质则无法赋值。这些情况使得性质本身的建造涉及到复杂的商业逻辑。这时候,此对象相当于一个有待建造的产品,而对象的这些性质相当于产品的零件,建造产品的过程是建造零件的过程。由于建造零件的过程很复杂,因此,这些零件的建造过程往往被“外部化”到另一个称做建造者的对象里,建造者对象返还给客户端的是一个全部零件都建造完毕的产品对象。
      建造模式利用一个导演者对象和具体建造者对象一个个地建造出所有的零件,从而建造出完整的产品对象。建造者模式将产品的结构和产品的零件的建造过程对客户端隐藏起来,把对建造过程进行指挥的责任和具体建造者零件的责任分割开来,达到责任划分和封装的目的。
      构造者模式的结构:
      这里写图片描述
    抽象建造者(Builder)角色:给 出一个抽象接口,以规范产品对象的各个组成成分的建造。一般而言,此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者 (ConcreteBuilder)角色。具体建造者类必须实现这个接口所要求的两种方法:一种是建造方法(buildPart1和 buildPart2),另一种是返还结构方法(retrieveResult)。一般来说,产品所包含的零件数目与建造方法的数目相符。换言之,有多少 零件,就有多少相应的建造方法。
    具体建造者(ConcreteBuilder)角色:担任这个角色的是与应用程序紧密相关的一些类,它们在应用程序调用下创建产品的实例。这个角色要完成的任务包括:1.实现抽象建造者Builder所声明的接口,给出一步一步地完成创建产品实例的操作。2.在建造过程完成后,提供产品的实例。
    导演者(Director)角色:担任这个角色的类调用具体建造者角色以创建产品对象。应当指出的是,导演者角色并没有产品类的具体知识,真正拥有产品类的具体知识的是具体建造者角色。
    产品(Product)角色:产品便是建造中的复杂对象。一般来说,一个系统中会有多于一个的产品类,而且这些产品类并不一定有共同的接口,而完全可以是不相关联的。
    导演者角色是与客户端打交道的角色。导演者将客户端创建产品的请求划分为对各个零件的建造请求,再将这些请求委派给具体建造者角色。具体建造者角色是做具体建造工作的,但是却不为客户端所知。
    一般来说,每有一个产品类,就有一个相应的具体建造者类。这些产品应当有一样数目的零件,而每有一个零件就相应地在所有的建造者角色里有一个建造方法。
    代码如下:

    public class ConcreteBuilder implements Builder{
    
        private Product product = new Product();
    
        /**
         * 产品零件构造方法1
         */
        public void builderPart1() {
            System.out.println("构建第一个零件");
            product.setPart1("id:123");
        }
    
        /**
         * 产品零件构造方法2
         */
        public void builderPart2() {
            System.out.println("构建第二个零件");
            product.setPart2("名称:变形金刚");
        }
    
        /**
         * 产品返还方法
         */
        public Product retrieveResult() {
            return product;
        }
    
    }
    public class Director {
    
        /**
         * 持有当前使用的构造器对象
         */
        private Builder builder;
    
        public Director(Builder builder) {
            super();
            this.builder = builder;
        }
    
        public void construct(){
            builder.builderPart1();
            builder.builderPart2();
        }
    }
    public static void main(String[] args) {
            Builder builder = new ConcreteBuilder();
            Director director = new Director(builder);
            director.construct();
    
            Product product = builder.retrieveResult();
            System.out.println(product.getPart1()+" "+product.getPart2());
    
        }
    展开全文
  • Java设计模式:构造者(Builder)模式

    千次阅读 2018-07-22 09:59:40
    //注意无参构造器私有,避免外界使用构造器创建User对象 private User() { } @Override public String toString() { return "User [name=" + name + ", age=" + age + ", phone=" + phone + ", email=" + ...
  • 构造者模式

    千次阅读 2010-11-22 11:09:00
    一、建造模式简介(Brief Introduction) 建造模式(Builder Pattern),将一个复杂对象的构建与它的表示分离,使的同样的构建过程可以创建不同的表示。 建造模式的优点是:使得建造代码与表示代码...
  • 下面就详细比较下三之间的区别以及它们的具体实现 1.构造函数 构造函数是一种特殊的类成员函数,是当创建一个类的对象时,它被调用来对类的数据成员进行初始化和分配内存。(构造函数的命名必须和类名完全相同) ...
  • Kotlin - 改良构建模式

    千次阅读 2022-03-06 20:17:58
    欢迎关注微信公众号:FSA全栈行动 Kotlin - 改良工厂模式 Kotlin - 改良构建模式 ...核心操作:私有化复杂对象(Product)的类构造器,设计并创建 Builder 类。 二、使用构建模式 例子:.
  • SpringCloud分布式微服务项目搭建构造父子模块依赖与实现服务提供与消费示例 SpringCloud分布式微服务项目搭建构造父子模块依赖与实现服务提供与消费示例 SpringCloud分布式微服务项目搭建构造父子模块依赖...
  • 先用一张图简单的概括下这几之间的关系,再细化: 构造函数和实例对象 构造函数是类的外在表现,构造函数的名字通常用作类名。 其实构造函数也就是一个函数,只不过它于普通的函数又有点不同: 没有显示的创建...
  • Notification notification = new Notification.Builder(this) .setContentTitle("title") .setContentText("content") .setSmallIcon(R.mipmap.ic_launcher) .build();
  • 设计模式-建造模式(造房子哪有这么简单)

    千次阅读 多人点赞 2021-02-05 22:03:34
    建造模式(Builder Pattern)又叫生成器模式,是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。 一步一步创建一个复杂的...
  • 手把手教会你使用建造模式

    万次阅读 2020-09-12 15:43:30
    建造模式可以简单理解为搭积木建房子,是我们一步一步、一层一层来搭建对象的过程,属于创建型模式,一般对象会提供一个Builder来进行构造。在构建的过程中我们不需要知道构建的过程,我们只需要告诉构建我想要...
  • matlab代码实现gallager校验矩阵构造,过程详细,已验证可行,适合初学,大家可以自己先试试编一下在对比一下,不难。
  • 建造者模式【设计模式】(八)–创建型模式–建造者模式建造者模式定义构造者模式的优点构造者模式的使用场景构造者模式和工厂模式区别构造者模式简单实现 建造者模式定义 Separate the construction of a complex ...
  • Android 设计模式之构造者Builder模式

    千次阅读 2021-11-10 08:45:51
    构造者模式在开发中也是常用的设计模式, 接下来就来讲一个构造者Builder模式 public class PersonEntry { private int id; private String name; public int getId() { return id; } public String getName...
  • 在Lombok中使用这三个annotation来完成项目中对于不同构造方法的需求。 @NoArgsConstructor : 生成一个无参数的构造方法,这个annotation在与其他的annotation配合起来使用的时候更加能凸显出他的重要性,当在使用...
  • 因为构造器可以提供许多特殊的方法,这个对于初学经常混淆。但是,构造器和方法又有很多重要的区别。  原作者:Robert Nielsen 原站:www.javaworld.com  我们说构造器是一种方法,象讲澳大利亚的鸭嘴兽是一种...
  • 静态工厂和构造器都有个局限:不能对大量可选参数做很好的扩展。 比如一个类,表示包装食品上的营养标签。 这些标签上有一些字段是必需的,如:净含量、毛重和每单位份量的卡路里; 另有超过 20 个可选的字段,如:...
  • 构造函数重载

    2015-04-24 15:37:26
    在vs2010上写的一个构造函数重载的例子,代码非常简单易懂,适合初学参考。
  • 神经网络案例分模块构造神经网络视频教程,希望能够学习提供帮助,实现对神经网络案例分模块构造神经网络基础知识的掌握与理解,为后续学习做好铺垫

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 826,108
精华内容 330,443
关键字:

构造者

友情链接: car.zip