Effective Java

第1条：考虑用静态工厂方法代替构造器

【尚未彻底读懂笔者的意图】

第2条：遇到多个构造器参数时要考虑用构造器

1.使用重叠构造器：缺点是写太多

2.使用JavaBean模式：缺点是不一致

3.使用Builder模式：先创造构造器，太冗长

Builder模式：

public class NutritionFacts{
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder{
        private final int servingSize;
        private final int servings;

        private int calories=0;
        private int fat=0;
        private int sodium=0;
        private int carbohydrate=0;

        public Builder(int servingSize,int servings){
            this.servingSize=servingSize;
            this.servings=servings;
        }

        public Builder calories(int value){
            calories=value;
            return this;
        }

        public Builder fat(int value){
            fat=value;
            return this;
        }

        public Builder sodium(int value){
            sodium=value;
            return this;
        }

        public Builder carbohydrate(int value){
            carbohydrate=value;
            return this;
        }

        public NutritionFacts build(){
            return new NutritionFacts(this);
        }

    }

    private NutritionFacts(Builder builder){
        servingSize=builder.servingSize;
        servings=builder.servings;
        calories=builder.calories;
        fat=builder.fat;
        sodium=builder.sodium;
        carbohydrate=builder.carbohydrate;
    }

    public static void main(String[] args){
        NutritionFacts cocaCola=new NutritionFacts.Builder(240,8).calories(100).sodium(35).carbohydrate(27).build();
        System.out.println("cocaCola nutritionfacts build success.");
    }
}

第3条：用私有构造器或者枚举类型强化Singleton属性

 1.公有静态成员是个final域：缺点是享有特权的客户端可以通过AccessibleObject.setAccessible方法，通过反射机制调用私有构造器

public class Elvis{
    public static final Elvis INSTANCE=new Elvis();
    private Elvis(){}
}

2.公有的成员是个静态工厂方法：

public class Elvis{
    private static final Elvis INSTANCE=new Elvis();
    private Elvis(){}
    public static Elvis getInstance(){
        return INSTANCE;
    }
}

同时，在利用静态工厂方法实现Singleton类变成可序列化的，仅仅在声明上加上implements Serializable是不够的。为了维护并且保证Singleton，必须声明所有实例都是瞬时的，并且提供一个readResolve方法。否则，每次反序列化一个序列化的实例时，都会创建一个新的实例。【尚未清楚，为啥加了readResolve方法就能防止】

public class Elvis{
    private static final Elvis INSTANCE=new Elvis();
    private Elvis(){}

    public static Elvis getInstance(){
        return INSTANCE;
    }

    private Object readResolve(){
        return INSTANCE;
    }
}

3.编写一个包含单个元素的枚举类型：

public enum Elvis{
    INSTANCE;

    public void leaveTheBuilding(){}
}

单元素的枚举类型已经成为了实现Singleton的最佳方法。

第4条：通过私有构造器强化不可实例化的能力：

public class UtilityClass{
    private UtilityClass(){
        throw new AssertionError();
    }
}

第5条：避免创建不必要的对象

1.通常使用静态工厂方法而不是构造器，以避免创建不必要的对象。

class Person{
    private final Date birthDate;
    private static final Date BOOM_START;
    private static final Date BOOM_END;

    static{
        Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946,Calendar.JANUARY,1,0,0,0);
        BOOM_START=gmtCal.getTime();
        gmtCal.set(1965,Calendar.JANURAY,1,0,0,0);
        BOOM_END=gmtCal.getTime();
    }

    public boolean isBabyBoomer(){
        return birthDate.compareTo(BOOM_START)>=0&&bithDate.compareTo(BOOM_END)<0;
    }
}

2.如果可以的话，使用延迟初始化(lazily initializing)。但是不太建议这么做，因为会使方法更加复杂。

3.考虑使用适配器(adapter)的情况：将功能委托给一个后备对象，从而为后备对象提供一个可以替代的接口。

4.要优先使用基本类型，而不是装箱基本类型，要担心无意识的自动装箱。

public class Test {
    public static void main(String[] args) {
        Long sum = 0L;
        /* long sum=0L; */
        for (long i = 0; i < Integer.MAX_VALUE; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

5.小对象的创建和回收动作是非常廉价的

6.通过维护自己的对象池来避免创建对象并不是一种好的做法，除非对象池中的对象是非常重量级的。

第6条：消除过期的对象引用