使用静态工厂方法代替构造器

1. 静态工厂方法有名字，客户端代码更易于阅读
2. 不必每次调用都创建新的对象
3. 可以返回原返回类型的任意子类类型
4. 创建参数化实例的时候，可以使代码更加简洁

多个构造器参数使用构造器

public class BuilderPattern {
    private final int servingSize;
    private final int savings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder{
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters
        private int calories;
        private int fat;
        private int sodium;
        private int carbohydrate;

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

        public Builder calories(int val){
            this.calories = val;
            return this;
        }
        public Builder fat(int val){
            this.fat = val;
            return this;
        }
        public Builder sodium(int val){
            this.sodium = val;
            return this;
        }
        public Builder carbohydrate(int val){
            this.carbohydrate = val;
            return this;
        }

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

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

    @Override
    public String toString() {
        return "BuilderPattern{" +
                "servingSize=" + servingSize +
                ", savings=" + savings +
                ", calories=" + calories +
                ", fat=" + fat +
                ", sodium=" + sodium +
                ", carbohydrate=" + carbohydrate +
                '}';
    }
}

私有构造器或枚举类型强化Singleton属性

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

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

避免创建不必要的对象

优先使用基本类型而不是封装类型

消除过期的对象

内存泄漏问题

避免使用终结方法