读 effective java 中文版第二版读后感（第一天）

第一条 考虑使用静态工厂代替构造器
java中的Boolean.valueOf()方法
例一

  public static final Boolean TRUE = new Boolean(true);
  /**
   * The {@code Boolean} object corresponding to the primitive
   * value {@code false}.
   */
  public static final Boolean FALSE = new Boolean(false);
  public static Boolean valueOf(boolean b) {
      return (b ? TRUE : FALSE);
  }

它通过首先去定义和实现好一个实例方法，等到我们需要创建此对象的时候直接可以获取到以前已经创建好的对象，而避免了创建对象消耗的资源信息
例二

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

通过代码分析，当需要创建么个Integer对象的时候首先从原先已经保存好的一个数组中获取当前数字的对象，当原来的数据不存在当前的对象的时候，才去考虑重新创建一个新的对象返回
通过以上的代码分析和作者的初衷，我的读后感是此条最终的目的是节省创建对象所造成的内存消耗，避免了资源的浪费，从而提升效率。
第二条 遇见多参数的情况时要考虑使用构建器

public class Booleans {
    private String username;
    private String password;
    private String salt;
    public Booleans(String username){
        this(username,"");
    }
    public Booleans(String username,String password){
        this(username,password,"");
    }
    public Booleans(String username,String password,String salt){
        this.username=username;
        this.password=password;
        this.salt=salt;
    }
}

当我们遇到这种情况去构造多个参数的构造器的时候，我们可能第一个选择就是重叠构造器去实现此方法，但是到成员变量越来越多的时候，客户端代码很难编写，并且难以阅读。
最简单的方式是使用默认构造方法，之后通过setter,getter方式去实现，但是按照书上说的存在一致性问题，
这时候就是java的buider模式使用的时候

package com.xuxing.api;

public class Booleans {
    private final String username;
    private final String password;
    private final String salt;

    private Booleans(Builder builder) {
        this.username = builder.username;
        this.password = builder.password;
        this.salt = builder.salt;
    }

    public static class Builder {
        private String username = "";
        private String password = "";
        private String salt = "";

        public Builder username(String username) {
            this.username = username;
            return this;
        }

        public Builder password(String password) {
            this.password = password;
            return this;
        }

        public Builder salt(String salt) {
            this.salt = salt;
            return this;
        }

        public Booleans builder() {
            return new Booleans(this);
        }
    }

    public Booleans(String username) {
        this(username, "");
    }

    public Booleans(String username, String password) {
        this(username, password, "");
    }

    public Booleans(String username, String password, String salt) {
        this.username = username;
        this.password = password;
        this.salt = salt;
    }
    public static void main(String[] args){
        Booleans booleans = new Booleans.Builder().password("wangwu").builder();
    }
}

这个的编程方式可以使构建参数的时候没有参数的先后顺序，构造起来更灵活。
心得
此方法解决了重叠构造方法的冗余，代码难以读取的问题，但是构造起来没有setter,getter方法的实现用起来简单，在web开发中使用可变对象我觉得还是使用setter,getter方法去实现，builder创建对象参数灵活，并且扩展性很好