精华内容
下载资源
问答
  • build设计模式

    2019-09-22 23:20:19
    又叫生成器模式 public class MainActivity extends AppCompatActivity { TextView textView; Button button; protected void onCreate(Bundle savedInstanceState) { super.onCreate(sa...

    又叫生成器模式

    public class MainActivity extends AppCompatActivity {
    
        TextView textView;
        Button button;
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            textView = findViewById(R.id.text);
            button = findViewById(R.id.button);
    
            Student.Builder builder = new Student.Builder();
            String address = builder.address("北京").name("四环").build().getAddress();
            System.out.println(address);
        }
        }

    public class Student {
    
        private int id;
        private String name;
        private String passwd;
        private String sex;
        private String address;
    
        // 构造器尽量缩小范围
        private Student() {
        }
    
        // 构造器尽量缩小范围
        private Student(Student origin) {
            // 拷贝一份
            this.id = origin.id;
            this.name = origin.name;
            this.passwd = origin.passwd;
            this.sex = origin.sex;
            this.address = origin.address;
        }
    
        public int getId() {
            return id;
        }
    
        public String getName() {
            return name;
        }
    
        public String getPasswd() {
            return passwd;
        }
    
        public String getSex() {
            return sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        /**
         * Student的创建完全依靠Student.Builder,使用一种方法链的方式来创建
         *
         */
        public static class Builder {
    
            private Student target;
    
            public Builder() {
                target = new Student();
            }
    
            public Builder address(int id) {
                target.id = id;
                return this;
            }
    
            public Builder name(String name) {
                target.name = name;
                return this;
            }
    
            public Builder password(String passwd) {
                target.passwd = passwd;
                return this;
            }
    
            public Builder sex(String sex) {
                target.sex = sex;
                return this;
            }
    
            public Builder address(String address) {
                target.address = address;
                return this;
            }
    
            public Student build() {
                return new Student(target);
            }
    
        }
    
    }

     

    转载于:https://www.cnblogs.com/Ocean123123/p/11023405.html

    展开全文
  • Build设计模式

    2017-06-29 11:41:00
    Builder模式的使用

    Builder模式的定义是用于构建复杂对象的一种模式,所构建的对象往往需要多步初始化或赋值才能完成。那么,在实际的开发过程中,我们哪些地方适合用到Builder模式呢?其中使用Builder模式来替代多参数构造函数是一个比较好的实践法则。

    • build设计模式有两种写法(该模式一般用于参数设置比较多的时候,且有一些参数可以有默认值即不是必须设置的项)

    我们有时候会写这样的实现类

    Student();
    Student(String name);
    Student(String name,int age);
    Student(String name,int age,String address);
    Student(String name,int age,String address,String ID);

    为了满足不同的需求有时候必须要这样,把所有的构造函数都声明。这样书写很常见并且也比较有效率但是也存在很多不足,比如类的作者必须好把所有的构造函数都写上,而且在实例化的时候也要写默认值。比如new Student(“张三”,-1,”北京”);年龄为-1肯定不符合常理,但是在实例化一个对象的时候必须要这种默认值,这是规范的要求否则直接报错了。如果没有使用setAge(int age)方法修改age的值,对于代码的后期维护和协同开发同伴使用肯定会是一件很痛苦的事情,因为根本不知道-1的含义是什么。这时候使用Builder模式就很有必要了。Builder模式就是使用一个代理完成对象的构建过程。这样的好处是易于扩展和类的使用,但同时失去了一些效率。

    public class Student{
         private String name;
         private int age;
         private  String address;
         private String ID;
         private Student(Builder build){
             this.name=build.name;
             this.age=build.age;
             this.address=build.address;
             this.ID=build.ID;
          }
          public String  getName(){
            return this.name;
          }
          public String getAge(){
           return this.age;
          }
          public String  getAddress(){
              return this.address;
          }
          public String getID(){
              return this.ID;
          }
          public void method(){
              System.out.println(name);
         }
         static class Builder{
            private String name=null;
            private int age=0;
            private String address=null;
            private String ID=null;
            public Builder(){};
            public Builder(String name){this.name=name}; //可以不写
            public Builder setName(String name){this.name=name;return this;}
            public Builder setAge(int age){this.age=age;return this;}
            public Builder setAddress(String address){this.address=address;return this;}
            public Builder setID(String ID){this.ID=ID;return this;}
            public Student build(){return new Student(this)}
          }
     }

    最后客户程序可以很灵活比如

    Student student=new Student.Builder()
    .setName("zhangsan")
    .setAge(12)
    .setAddress("beijing")
    .build();`

    这样就可以调用 student.getName()和getAge()等方法了。这样写会丧失一定的效率但是代码易于扩展和使用。如果对student类进行了修改加入了新的成员变量,那么只需简单修改几行代码。如果不这样写构造函数可能要添加很多喽!因为构造函数参数个数和组合有很多种。。
    ==============================分割线====================================
    实际的开发中Build设计模式可能有两种:

    • 将外部类作为builder类的成员变量 如:
    class C {
        public  String arg;
        ...........
        static class B {
            public C  c;
            public B (参数) {
                c = new C(参数) 
            }
            public B setArg(参数 arg) {
                c.arg = arg;
                return this;
            }
            public C  build () { return c; }
        }
    }
    • 将Builder类作为外部类的成员变量 如:
    class C {
        public String arg;
        public Builder b;
        public C (Builder b){
            this.arg = b.arg;
        }
        static class B {
            public String arg;
            public B () {}
            public B setArg (参数 arg) {
            this.arg = arg;
                return this;
            }
            public C build () {return new C (this);}
        }
    } 
    展开全文
  • Java设计模式之build设计模式

    千次阅读 2018-07-06 10:32:19
    模式简介build设计模式是Java开发中常用的一种实例化对象的设计模式,在谷歌的guava和rabbitmq的开发中用到了很多。Java Builder模式主要是用一个内部类去实例化一个对象,避免一个类出现过多构造函数,而且构造函数...

    模式简介

    build设计模式是Java开发中常用的一种实例化对象的设计模式,在谷歌的guava和rabbitmq的开发中用到了很多。Java Builder模式主要是用一个内部类去实例化一个对象,避免一个类出现过多构造函数,而且构造函数如果出现默认参数的话,很容易出错。build设计模式类似于通过一个代理来构建对象,可以对对象起到更好的封装作用。

    应用场景

    1.实例化对象时需要传入的参数过多,而且并不是所有的参数都是我们需要的,如果采用构造方法或是set方法传参数的话,代码重复很高,且不利于维护。

    2.当有的参数作为策略是可选时。

    代码(别的都是废话,技术本人认为最好的学习方式就是看代码)

    package rabbitmq58lib.model;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * Created with IntelliJ IDEA.
     * Description:
     * User: weicaijia
     * Date: 2017-08-28
     * Time: 14:37
     */
    public class RabbitExchangeModel {
        private String ServerUrl;
        private int Port;
        private String UserName;
        private String Pwd;
        private String QueueName;
        private String ExchangeName;
        private String Type;
        private String ConsumerKey;
        private String ProducerKey;
        private boolean isDLX;
        private String DLE;
        private String DLK;
        private TimeUnit retryTimeUnit;
        private long retryDelaytime;
        private int retries;
        private boolean isRetried;
    
        private RabbitExchangeModel(Builder builder) {
            this.ServerUrl = builder.ServerUrl;
            this.Port = builder.Port;
            this.UserName = builder.UserName;
            this.Pwd = builder.Pwd;
            this.QueueName = builder.QueueName;
            this.ExchangeName = builder.ExchangeName;
            this.Type = builder.Type;
            this.ConsumerKey = builder.ConsumerKey;
            this.ProducerKey = builder.ProducerKey;
            this.isDLX = builder.isDLX;
            this.DLE = builder.DLE;
            this.DLK = builder.DLK;
            this.retryTimeUnit = builder.retryTimeUnit;
            this.retryDelaytime = builder.retryDelaytime;
            this.retries = builder.retries;
            this.isRetried = builder.isRetried;
        }
    
         public static class Builder {
            private String ServerUrl;
            private int Port;
            private String UserName;
            private String Pwd;
            private String QueueName;
            private String ExchangeName;
            private String Type;
            private String ConsumerKey;
            private String ProducerKey;
            private boolean isDLX;
            private String DLE;
            private String DLK;
            private TimeUnit retryTimeUnit;
            private long retryDelaytime;
            private int retries;
            private boolean isRetried;
            private boolean Durable = true;
    
            public Builder(String ServerUrl, int Port, String UserName, String Pwd, String ExchangeName, String Type) {
                this.ServerUrl = ServerUrl;
                this.Port = Port;
                this.UserName = UserName;
                this.Pwd = Pwd;
                this.ExchangeName = ExchangeName;
                this.Type = Type;
            }
             public Builder QueueName(String QueueName) {
                 this.QueueName = QueueName;
                 return this;
             }
            public Builder ConsumerKey(String ConsumerKey) {
                this.ConsumerKey = ConsumerKey;
                return this;
            }
    
            public Builder ProducerKey(String ProducerKey) {
                this.ProducerKey = ProducerKey;
                return this;
            }
    
            public Builder isDLX(boolean isDLX) {
                this.isDLX = isDLX;
                return this;
            }
    
            public Builder DLE(String DLE) {
                this.DLE = DLE;
                return this;
            }
    
            public Builder DLK(String DLK) {
                this.DLK = DLK;
                return this;
            }
    
            public Builder retryTimeUnit(TimeUnit retryTimeUnit) {
                this.retryTimeUnit = retryTimeUnit;
                return this;
            }
    
            public Builder retryDelaytime(long retryDelaytime) {
                this.retryDelaytime = retryDelaytime;
                return this;
            }
    
            public Builder retries(int retries) {
                this.retries = retries;
                return this;
            }
    
            public Builder isRetried(boolean isRetried) {
                this.isRetried = isRetried;
                return this;
            }
    
            public Builder Durable(boolean Durable) {
                this.Durable = true;
                return this;
            }
    
            public RabbitExchangeModel build() {
                return new RabbitExchangeModel(this);
            }
        }
    
        public String getServerUrl() {
            return ServerUrl;
        }
    
        public int getPort() {
            return Port;
        }
    
        public String getUserName() {
            return UserName;
        }
    
        public String getPwd() {
            return Pwd;
        }
    
        public String getQueueName() {
            return QueueName;
        }
    
        public String getExchangeName() {
            return ExchangeName;
        }
    
        public String getType() {
            return Type;
        }
    
        public String getConsumerKey() {
            return ConsumerKey;
        }
    
        public String getProducerKey() {
            return ProducerKey;
        }
    
        public boolean isDLX() {
            return isDLX;
        }
    
        public String getDLE() {
            return DLE;
        }
    
        public String getDLK() {
            return DLK;
        }
    
        public TimeUnit getRetryTimeUnit() {
            return retryTimeUnit;
        }
    
        public long getRetryDelaytime() {
            return retryDelaytime;
        }
    
        public int getRetries() {
            return retries;
        }
    
        public boolean isRetried() {
            return isRetried;
        }
    }
                                                                                                                                                                                    

    弊端

    目前该代码存在一个问题,就是对已经创建的对象的修改的问题,当然我们可以通过加set方法去实现。

    ps:附上一篇build精华帖,转载自:java设计模式之建造者模式

    展开全文
  • 我们都知道,Android源码中AlertDialog就是使用Build设计模式,这种模式的主要特点就是链式的,方便使用者的调用,使用者无需关心内部如何实现就可以方便调用。好,接下来用一个demo来说明。 在我理解来,实现Build...

    我们都知道,Android源码中AlertDialog就是使用Build设计模式,这种模式的主要特点就是链式的,方便使用者的调用,使用者无需关心内部如何实现就可以方便调用。好,接下来用一个demo来说明。

    在我理解来,实现Build设计模式,主要两个核心类,一个是你的目标对象,一个是Buider对象。首先我们定义一个Target对象,这个对象就是类似AlertDailog这个类,就是使用者要调用的类。

    public class Target {
        private String mTitle;
        private String mMessage;
        private int mIcon;


        public static TargetBuilder builder(){
            return new TargetBuilder();
        }


        public Target() {
        }


        public Target(String mTitle, String mMessage, int mIcon) {
            this.mTitle = mTitle;
            this.mMessage = mMessage;
            this.mIcon = mIcon;
        }


        public Target showText(){//目标对象调用方法
            System.out.println(mTitle+mMessage+mIcon);
            return this;
        }
    }


    Target 类中我们可以看到,需要title、message、icon三个属性,我们在这个类中并没有直接给他们赋值,而是通过Builder类给他赋值。


    接着再创建Builder类:

    public class TargetBuilder {
        private String mTitle;
        private String mMessage;
        private int mIcon;


        public TargetBuilder setTitle(String title) {
            this.mTitle = title;
            return this;
        }


        public TargetBuilder setMessage(String message) {
            this.mMessage = message;
            return this;
        }


        public TargetBuilder setIcon(int icon) {
            this.mIcon = icon;
            return this;
        }


        public Target build(){
            return new Target(mTitle,mMessage,mIcon);
        }
    }


    其实,说到底,Builder类就是一个赋值和传值的类,如例,我们可以通过set方法给各个属性赋值,但必须有Builder的对象,所以我们在Target中定义一个静态方法,来创建Builder对象,然后就可以给Builder中的属性赋值了,赋值的过程有个重点,就是返回值必须返回当前对象,这样子赋值完一个值后方便继续给下一个属性赋值,赋值完后,我们在Builder类中再通过一个builde()方法,其实就是创建Target对象,本质就是把值传到Target类中,这个时候Target的属性就有值了,我们在Target里面创建我们需要的方法就可以。


    展开全文
  • 有时候我们要经常给一个类去赋值,但是参数过多时,记不清楚参数和属性的对应了,所以我们就引入Build设计模式了。接下来我用一个类来简单模拟一个Build设计模式。 public class User { private String name; ...
  • 多构造器参数使用build设计模式

    千次阅读 2019-10-28 21:30:46
    最近看HDFS源码,看到写副本时,ReplicaInfo类使用到了build设计模式,所以整理这篇文章,加深学习。 提出问题 当一个业务复杂的类包含多个属性时,如果我们想要创建实例对象时,就必须定义构造器,针对属性的可选性...
  • Build模式是一步一步创建复杂对象的模式。允许用户在不知道内部构造细节的情况下,可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和构造它的部件解耦,使得构建的过程和部件的表示隔离开,两者...
  • java build设计模式

    2016-08-03 10:23:17
    使用场景: 1.构造函数参数非常多的情况,这种情况下,如果构造传入大量参数,程序的可读性会非常差 2.有一些构造函数的...2.这和典型的四人帮builder模式是有点不一样的,但设计模式不就是给个模板,然后让使用者自
  • 设计模式Build模式

    2021-02-04 16:26:27
    Build模式作用: 让对象的创建过程变成链式的,增加代码可读性; 在Android中的常见用例: 对话框的创建,Okhttp的使用 没有用build模式一般会这样去构建对象类: 缺点:在构建对象的时候,代码可读性差; ...
  • 设计模式-build模式

    2018-12-07 10:48:06
    build也是我们很常用的设计模式,他的主要应用场景是创建对象并对对象赋值,有的同学可能说我直接创建一个对象,用set方法也能对对象赋值。那么build模式和对象set方法的区别是什么呢,我们先来看看bulid模式的实现 ...
  • 设计模式 Build 模式

    千次阅读 2017-10-13 17:16:58
    Builder模式介绍Builder模式是一步一步创建一个复杂对象的创建性模式,他允许用户在不知道内部构建细节的情况下,可以更加准确的控制对象的构造流程,该模式是为了将构建复杂对象过程和他的部件解耦使得构建过程和...
  • 设计模式build模式

    2019-10-08 14:51:19
    @设计模式build模式 简介 Builder模式是一步一步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦,...
  • 设计模式build模式

    2019-05-31 09:53:44
    build模式是为使复杂对象,简单化 。 public class Blog { private String name; private int age; private String address; private String ID; private Blog(Builder builder) { this.name ...
  • Builder模式介绍 Builder模式是一步一步创建一个复杂对象的创建性模式,他允许用户在不知道内部构建细节的情况下,可以更加准确的控制对象的构造流程,该模式是为了将构建复杂对象过程和他的部件解耦使得构建过程和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 816
精华内容 326
关键字:

build设计模式