zoukankan      html  css  js  c++  java
  • Builder Pattern(译)

    Builder pattern vs Constructor vs Setter

    You could have built an object with this:

    // Example 1
    
    new FlyingMachine("Boeing 787", 2, false);
    

    Or this:

    // Example 2
    
    FlyingMachine plane = new FlyingMachine();
    plane.setName("Boeing 787");
    plane.setNumEngine("Boeing 787");
    plane.setHasRocketBooster(false);
    

     

    Example one (Constructor based instantiation)

    In example one, the object is created through constructor. There are multiple downsides with this

    The arguments passing into the constructor are not meaningful

    What the hell does 2 and false exactly mean?

    In comparison the builder pattern has done a great job explaining the values .numEngine(2) and .hasRocketBooster(false)

    The arguments are all passed in one line making it nearly impossible to read

    You may arrange like this

    new FlyingMachine( "Boeing 787", 2, false);

    But I doubt it really improves readability

    You cannot omit parameters

    When one day you realize that you do not want to name that flying machine, you may choose to pass in null for name

    new FlyingMachine(null, 2, false);

    But using the builder pattern, you can simply remove this line: .name("Boeing 787")

     
    Example two (Setter method)

    In example two, the internal properties of the object are set by setters after instantiation. It essentially achieves the same effects as the two other methods, but it has a completely different semantic meanings. This method creates an empty object and fills in the details later, which bypasses the constructor completely and these properties cannot be used during initialization. In reality, you won’t build an aircraft without knowing what’s inside, right?

     

    摘录自 effective java

    public class DoDoContact {
        private final int    age;
        private final int    safeID;
        private final String name;
        private final String address;
     
        public static class Builder {
            private int    age     = 0;
            private int    safeID  = 0;
            private String name    = null;
            private String address = null;
               
            // name必要
            public Builder(String name) {
                this.name = name;
            }
     
            public Builder age(int val) {
                age = val;
                return this;
            }
     
            public Builder safeID(int val) {
                safeID = val;
                return this;
            }
     
            public Builder address(String val) {
                address = val;
                return this;
            }
     
            public DoDoContact build() { 
                // 通过builder构建实例
                return new DoDoContact(this);
            }
        }
     
        private DoDoContact(Builder b) {
            age = b.age;
            safeID = b.safeID;
            name = b.name;
            address = b.address;
     
        }
    }                
    

      

    DoDoContact ddc = new DoDoContact.Builder("Ace").age(10)
                    .address("beijing").build();
    System.out.println("name=" + ddc.getName() + "age =" + ddc.getAge()
                    + "address" + ddc.getAddress());
    

      

    reference:

    https://www.cnblogs.com/moonz-wu/archive/2011/01/11/1932473.html

    https://hermannyung.com/2017/05/28/builder-pattern-vs-constructor-vs-setter/

  • 相关阅读:
    js对象的所有方法
    js数组的所有方法
    Scss语法
    new一个对象的过程
    promises的深入学习
    jsonp的原理介绍及Promise封装
    Vue页面缓存和不缓存的方法
    JavaScript数据类型
    JS常用函数原理的实现
    @Autowired注解在抽象类中实效的原因分析
  • 原文地址:https://www.cnblogs.com/lnas01/p/10367002.html
Copyright © 2011-2022 走看看