java 效率编程（创建对象）

一.考虑使用静态工厂方法代替构造器

1.因为静态工厂方法有名称，更容易体现方法的区别

2.使用静态方法不必每次调用都创建一个新的对象

3.可以返回原返回类型的任何子类型

3.1：API可以返回对象，同时有不会使对象的类成为共有的类型。

隐藏实现类，可能会使API更加简洁。（java的集合框架很多都是使用这种方式）

可以在底层随意更改实现，而不会影响客户端的使用。提高软件的可维护性

3.2： 静态方法返回的对象所属的类，在编写包含该静态工厂的类中可以不必存在。

这种灵活的静态工厂方法构造了服务提供者框架。

缺点是：

静态工厂的方法和其他的静态方法一样，因此必须提供惯用的名称：

valueOf  of  getInstance getType 等

interface  Service{
}

//service provider interface
interface Provider{
    Service newService();

}

public class Services {
    private static final Map<String,Provider> providers =
            new ConcurrentHashMap<String, Provider>();

    public static final String DEFAULT_PROVIDER_NAME = "<DEF>";

    //provider registration api
    public static void registDefaultProvider(Provider p){
        registProvider(DEFAULT_PROVIDER_NAME,p);
    }

    public static void registProvider(String name,Provider provider){
        providers.put(name, provider);
    }

    public static Service newInstance(String name){
        Provider p = providers.get(name);
        if(p == null){
            throw new IllegalArgumentException
                    ("no provider registered with name : "+name);
        }
        return  p.newService(); 
    }

二 .考虑使用构造器模式（如果有多个参数时候

环境：如果一个类有20多个域，其中只有两个是必选的，其他的域是非必选的。怎么做？

做法1.使用构造器，重载。(这里会导致很多方法非常相似，很容易出错)

做法2.javabean模式 （被分割到几个调用方法当中，导致javabean的不一致）

做法3.使用构造器模式

三.过期引用为题

import java.util.Arrays;
import java.util.EmptyStackException;

/**
 * Created by root on 15-12-20.
 */
public class Stack<T> {
    public Object[] elements;

    public int size = 0;

    public static final  int DEFAULT_INITAL_SIZE = 16;

    public void push(T t){
        ensureCapaciyt();
        elements[size++] = t;
    }
    public T pop(){
        if(size == 0){
            throw new EmptyStackException();
        }
        T t = (T)elements[--size];
        elements[size] = null;
        return t;
    }
    private void ensureCapaciyt() {
        if(size < elements.length){
            elements = Arrays.copyOf(elements,2*size+1);
        }
    }
}

1.当对象自己管理内存的时候，一旦元素被释放掉，则该元素中包含的任何元素引用都应该被清空。  

2.内存泄露的另一个常见来源是缓存

3.内存泄露的第三种常见问题是监听器和其他回调。

确保回调立即被当做垃圾回收的最佳方法是值保存他们的弱引用，只将他们保存成weakHashMap中的键