一.构造对象优先使用静态工厂方法

优点
1.有名称。BigInteger.probablePrime
2.不必每次都构建新的对象,进行复用 Boolean.valueOf()
3.它可以返回任意子类型的对象 <Key,Instance> Map getByName
4.代码变得简洁 HashMap.newInstance()
valueOf,of,getInstance,newInstance,newType
缺点
1.类如果不包含公共或者受保护的构造器,无法被实例化
2.与其它静态方法没有任何区别
3.静态构造器跟构造器有一个公共的局限性,就是不能很好的扩展大量的可选参数!!!

二.遇到多个构造器参数时要考虑构建器(大多数参数可选的情况下)

1.Builder模式解决,可读性好,可扩展性强

interface Builder<T> {
    public T build();
}
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 implements team.opay.pochat.android.Builder<NutritionFacts> {
        //required params
        private final int servingSize;
        private final int servings;

        //optional params
        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 calories) {
            this.calories = calories;
            return this;
        }

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

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

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

        @Override
        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;
    }
}

三.用私有构造器或者枚举类型强化Singleton属性

public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    private Elvis(){}
    public static Elvis getInstance() {
        return INSTANCE;
    }
}
可序列化?
1.Serializable
2.transient 否则每次序列化都是一个新的实例对象

enum ElvisII{
    INSTNACE;
    public void leaveTheBuilding() {}
}
无偿提供了系列化机制,绝对防止多次实例化 单元素的枚举类型已经成为单例的最佳方法!!!

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

public class UtilityClass {
    //不能被子类实例化
    // Suppress default constructor fon noninstantability
    private UtilityClass() {
        throw new AssertionError();
    }
}

五.避免创建不必要的对象

String s = new String("don 't do this");
Long sum = 0L;
1. 优先使用基本类型而不是装箱基本类型,要当心无意识的自动装箱
Object Pool;
2. 对象池? 不是一个很好的做法!!!除非对象池子的对象是非常重量级的 比如数据库连接池,建立的代码非常昂贵。

六.清除过期的对象引用

1.一般而言,只要类自己管理内存.就需要警惕内存泄漏.一旦元素释放掉.则该元素包含的任何对象引用都应该被清空。【Stack,Storage Pool,Elements array】
2.缓存导致内存泄漏。WeakHashMap代表缓存。！！！【生命周期不是Key决定】
3.监听器或者回调导致内存泄漏。