Effective Java 1-5

第一条：
内容：静态工厂替代构造函数
例子：String.valueOf()   getInstance()等
静态工厂方法优点：
1,可以随意起名字，更好的描述返回对象
2,每次调用的时候不一定要创建一个新对象
3,可以返回一个原返回类型的子类型对象
静态工厂方法的缺点：
1,如果类没有公有或者受保护的构造函数就不能被子类化
2,不符合规范，破坏规范。在API文档中不会被那么明确的标识出来。

第二条：使用私有构造函数强化单态
单态的模式大家都知道了，但是使用单态的时候记住要使用私有的构造函数。
原因很简单，如果不如此很难保证单态。只要new一下另一个对象就生成了

第三条：有些类是不能实例化的，如果你要做到这点，记得使用私有的构造函数。
例如：java.util.Collections        java.lang.Math 等

第四条：避免创造重复的对象
特别是这样的代码不要写： String str = new String("a string");
因为这样每次执行的时候都创建了一个"a string"对象。
可以写成这样：String str = "a string ";
另外顺便说一句，这个时候你再次定义String  str2 = "a string";会复用上边的字符串.

第五条：在有些情况下手动消除对象的引用

public   class  Stack {
    private Object[] elements;
    private int size = 0;
    public Stack(int initialCapacity){
        this.elements = new Object[initialCapacity];
    }
    public void push(Object e){
        ensureCapacity();
        elements[size++] = e;
    }
    public Object pop(){
        if (size == 0)
            throw new EmptyStackException();
        return elements[--size];
    }
    private void ensureCapacity(){
        if (elements.length == size){
            Object[] oldElements = elements;
            elements = new Object[2*element.length+1];
        System.arraycopy(oldElements,0,elements,0,size);
        }
    }
}

如果这个Stack先大量增长，然后收缩，然后在比较小的范围内使用，必定造成大量的不可回收的对象，造成内存泄漏.。
解决办法：改造一下pop()方法

public  Object pop() {
        if(size = = 0)
            throw new EmptyStackException();
        Object result = elements[--size];
                 //加上这一句
        elements.[size]=null;
        return result;
}