1.创建和销毁对象_EJ

在这里记录《Effective Java》学习笔记。该书介绍了java编程中70多种极具实用价值的经验规则，揭示了该做什么，不该做什么才能产生清晰、健壮和高效的代码。

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

对于类而言，为了让客户端获得它自身的实例，最常用的方法就是提供一个公有的构造器。还有一种方法就是提供一个静态工厂方法。下面是Boolean的一个简单示例。

public static Boolean valueOf(boolean b) {
     return (b ? TRUE : FALSE);
}

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

提供静态工厂方法而不是公有构造器有几大有点：

1.静态工厂方法有名称。

2.不必在每次调用它们的时候都创建一个新的对象。

3.可以返回原返回类型的任何子类型的对象。一个服务提供者框架的例子：

public interface Provider {
    Service newService();
}

public interface Service {
    //Service-specific methods go here
}

public class Services {
    private Services(){
        //prevents instantiation
    } 
    private static final String DEFAULT_PROVIDER_NAME = "<def>";
    private static final Map<String, Provider> providers = new ConcurrentHashMap<>();
    //Provider registration API
    public static void registerDefaultProvider(Provider p){
        registerProvider(DEFAULT_PROVIDER_NAME, p);
    }
    public static void registerProvider(String name, Provider p){
        providers.put(name, p);
    }
    
    //Service access api
    public static Service newInstance(){
        return newInstance(DEFAULT_PROVIDER_NAME);
    }
    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();
    }
}

4.在创建参数化类型实例的时候，它们使代码变得更加简洁。一个hashMap的例子：

Map<String, List<String>> m = new HashMap<String, List<String>>();    //这会显得很繁琐

public static <K, V> HashMap<K, V> newInstance() {
    return new HashMap<K, V>();
}
Map<String, List<String>> m = HashMap.newInstance();

但是实际上从JDK7（包括JDK7）之后的集合类可以用以下简洁的代码代替：

Map<String, List<String>> m = new HashMap<>();

静态工厂方法的缺点：

1.类如果不含有公有的或受保护的构造器，就不能被子类化。

2.它们与其它静态方法没有实质区别，如果要想查明如何实例化一个类，这是非常困难的。

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

静态工厂方法和构造器有个共同的缺点，不能很好地扩展到大量可选参数。考虑用一个类表示食品包装外的成分标签，这些标签的有些域是必需的，比如每份含量，有些是可选的，比如脂肪含量、胆固醇，钠等。采用重叠构造器模式可行，但是当有许多参数的时候，客户端代码就会很难写。采用JavaBean模式，然后用setter方法设置值也可行，但在构造过程中可能使JavaBean处于不一致的状态。幸运的是我们还可以使用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 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 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 String toString(){
        return "NutritionFacts create success";
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        NutritionFacts cocaCola = new NutritionFacts.Builder(240, 3).
                    calories(100).fat(33).sodium(99).carbohydrate(88).build();
        System.out.println(cocaCola.toString());
    }

}

可见builder方式非常灵活，简而言之，如果静态工厂方法和构造器中有多个参数，builder模式就是一个不错的选择。

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

实现singleton时，可以把构造器设为私有，并导出公有的静态成员。

public class Instance {
    public static final Instance instance = new Instance();
    private Instance(){}
}

也可以用静态工厂类，

//singleton with private final field
public class Instance2 implements Serializable{
    private static final Instance2 instance = new Instance2();
    private Instance2(){}
    public static Instance2 getInstance(){
        return instance;
    }
}

对于上面的两种方法，都会只返回同一个对象引用。公有域方法的好处是能清楚地知道这是一个Singleton类。工厂方法的优势之一在于它提供了灵活性，我们可以改变该类是否是Singleton的想法，第二个优势与泛型有关（见泛型模块，第27条）。

为了使Singleton类变成可序列化的，仅仅在申明中加上implements Serializable是不够的。为了维护并保证Singleton，必须提供一个readResolve方法，否则每次反序列化一个序列化实例时，都会创建一个新的实例。

//singleton with private final field
public class Instance2 implements Serializable{
    private static final Instance2 instance = new Instance2();
    private Instance2(){}
    public static Instance2 getInstance(){
        return instance;
    }
    private Object readResolve(){
        return instance;
    }
}

public class InstanceSerializable {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Instance2 instance = Instance2.getInstance();
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\objFile.obj"));
        out.writeObject(instance);
        out.close();
        
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\objFile.obj"));
        Instance2 instance11 = (Instance2) in.readObject();
         in = new ObjectInputStream(new FileInputStream("D:\objFile.obj"));
        Instance2 instance22 = (Instance2) in.readObject();
        in.close();
        System.out.println(instance11 == instance22);  //true
    }

}

实现Singleton还有第三种方法-枚举类型。

public enum EnumObj {
    INSTANCE;
}

这种方法与公有域方法类似，但它更加简洁，无偿地提供了序列化机制，绝对防止多次序列化。

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

有些工具类如Math类，Arrays类，Collections类不希望被实例化，实例化对他们没有意义。而通过做成抽象类来强制该类不可以被实例化也是行不通的，因为该类可以被子类化，子类可以被实例化。因此建议用private修饰构造器。

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

一般来说，最好能重用对象，而不是每次需要时就创建一个相同功能的对象。一个极端的反面例子：

String s = new String("str"); //Don't do this

如果这种用法在循环中，或是在一个频繁调用的方法中，则会创建成千上万个不必要的String实例。

String s = "str";

改进后的版本只会有一个实例，对于所有在同一虚拟机运行的代码，只要它们包含相同的字符串字面常量，该对象就会被重用。

除了重用不可变对象外，也可以重用已知不会被修改的可变对象。下面例子检验一个人是否是“高峰期出生的小孩”。

public class Person {
    private final Date birthDate;
    public Person(Date birthDate){
        this.birthDate = birthDate;
    }
    //Don't do this
    public boolean isBabyBoomer(){
        Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
        Date boomStart = gmtCal.getTime();
        gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
        Date boomEnd = gmtCal.getTime();
        return birthDate.compareTo(boomStart) >= 0 && birthDate.compareTo(boomEnd) < 0;
    }
}

每次调用isBabyBoomer方法时，都会创建一个Calendar，一个TimeZone和两个Date对象，这是没必要的。

public class Person2 {
    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.JANUARY, 1, 0, 0, 0);
        BOOM_END = gmtCal.getTime();
    }
    public Person2(Date birthDate){
        this.birthDate = birthDate;
    }
    public boolean isBabyBoomer(){
        return birthDate.compareTo(BOOM_START) >= 0 && birthDate.compareTo(BOOM_END) < 0;
    }
}

改造后，如果isBabyBoomer方法频繁调用，会显著提高性能，代码的含义也更加清晰了。

自动装箱（autoboxing）功能是一种创建多于对象的方法，它允许我们将基本类型和装箱基本类型混用，按需要自动装箱和拆箱。

public class LongTest {
    //hideously slow program! can you spot the object creation?
    public static void main(String[] args) {
        long start = Calendar.getInstance().getTimeInMillis();
        long sum = 0L;
        //Long sum = 0L; //不要使用Long对象，这样意味着程序会多构造2^31个Long实例
        for(long i=0; i < Integer.MAX_VALUE; i++){
            sum += i;
        }
        long end = Calendar.getInstance().getTimeInMillis();
        System.out.println(end - start);
    }
    protected void defaultTest(){
        System.out.println("包内访问权限");
    }
}

通过例子我们可以看出，要优先使用基本类型而不是装箱基本类型，要当心无意识的自动装箱。

这个条目并不是暗示“创建对象代价非常昂贵，我们应该尽可能地避免创建对象”。相反，有时通过创建附加对象，提升程序的清晰性、简洁性和功能性，这通常是件好事。比如第39条有关“保护性拷贝”的内容。而维护自己的对象池来避免创建对象也不见得是种好方法，除非池中的对象是非常重量级的，维护自己的对象池必定会把代码弄的很乱，同时增加内存占用，还会损害性能。

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

Java具有垃圾回收功能，当用完了对象之后，它们会被自动回收，但这并不代表不需要考虑内存回收的事了。一个栈内存泄漏的例子：

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
    public Stack(){
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }
    public void push(Object e){
        elements[size++] = e;
    }
    public Object pop(){
        if(size == 0){
            throw new EmptyStackException();
        }
        Object result = elements[--size];
        return result;
    }
    private void ensureCapacity(){
        if(elements.length == size){
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

这程序隐藏着个问题，程序中发生了内存泄漏，该类的pop（）方法有问题。从栈中弹出来的对象不会被垃圾回收，这是因为栈内部维护着对这些对象的过期引用（就是指永远不会被解除的引用），在这里指大于size的那些元素。修复很简单：

public Object pop(){
    if(size == 0){
        throw new EmptyStackException();
    }
    Object result = elements[--size];
    elements[size] = null;  //清空过期引用，不然会导致内存泄漏
    return result;
}

一般而言，只要是类自己管理内存，我们就应该警惕内存泄漏问题。内存泄漏的另一个常见来源是缓存，一旦把对象放到缓存中之后，就很容易被遗忘，从而在它不再使用之后很久一段时间内仍留在内存内。对于这种问题，我们可以用WeakHashMap代表缓存。内存泄漏的第三个常见来源是监听器和其他回调。对于这种情况最佳方法是只保存它们的弱引用，例如只将它们保存成WeakHashMap中的键。

第7条： 避免使用终结方法

终结方法指的就是finalize()方法，java语言规范不保证终结方法会被及时地执行，而且根本就不保证它们会被执行。所以不应该依赖终结方法更新重要的持久状态，例如依赖终结方法来释放共享资源（比如数据库）上的永久锁，很容易让整个分布式系统垮掉。

终结方法既然存在那它就并不是毫无用处，第一种用途就是充当一个“安全网”，终结方法“本该”是在GC前做一些清理动作，但GC的时间未知，也就是终结方法执行时间未知，对于FileInputStream类我们都知道应该在try-finally中对其调用close方法，但也许我们会忘记编写此方法，在FileInputStream源代码中就实现了终结方法目的就在于如果忘记了close方法，至少还有终结方法，虽然可能不能得到及时执行，但晚执行总比不执行好吧。第二个用途可能使用的场景就可能比较少，JVM只回收普通对象，对于本地对象（也就是不是Java实现的对象），JVM并不会对它进行回收，此时我们就可以在终结方法中对本地对象进行一些清理操作，但一定记住一定要是“不拥有关键资源的前提”，且在子类中重写了终结方法一定要现实调用super.finalize()，否则父类的终结方法不会被调用。

综上，对于终结方法，一般代码中并不会使用，如果要使用一定要考虑上面两种用途是否值得去做，万万不应该依赖终结方法来更新重要的持久状态。