《Effective Java 2nd》第2章 创建和销毁对象
第2章 创建和销毁对象
第1条：考虑使用静态工厂方法代替构造器
通过使用静态工厂方法而不是使用构造器来创建类。
举例：Boolean.valueOf(boolean)方法，将boolean转换为Boolean对象引用。
有以下优势：
1）静态工厂方法有名称，可以表示方法的意思
2）不必在每次调用的时候都创建新对象（对象缓存能力）。
不可变类可预先构建实例，缓存起来重复使用。
3）可以返回原返回类型的任何子类型的对象
4）在创建参数化类型的时候代码更简洁。
//我们平时创建list List<String> list = new Arraylist<>(); //使用google 工具类 List<String> list = Lists.newArrayList();
valueOf、of、getInstance、newInstance、getType、newType（如newArrayList)
第2条：遇到多个构造器参数时考虑用构建器
当有很多个构造参数，且有几个参数是可选的，考虑使用Builder
public class NutritionFacts { /** 必填参数 */ private final int servingSize; private final int servings; /** 可选参数 */ private final int fat; private final int sodium; public static class Builder { private final int servingSize; private final int servings; private int fat = 0; private int sodium = 0; public Builder(int servingSize, int servings) { this.servingSize = servingSize; this.servings = servings; } public Builder fat(int fat) { this.fat = fat; return this; } public Builder sodium(int sodium) { this.sodium = sodium; return this; } public P build() { return new P(this); } } private NutritionFacts(Builder builder) { this.servingSize = builder.servingSize; this.servings = builder.servings; this.fat = builder.fat; this.modium = builder.modium; } }
客户端代码
NutritionFacts p = new NutritionFacts.Builder(200, 8).fat(100).sodium(35).build();
更高级使用：
public interface Builder<T> { public T build(); }
public static class NutritionFacts.Builder implements Builder<P>
这样可以将Builder<NutritionFacts>传给方法，并结合抽象工厂创建NutritionFacts实例。
第3条：用私有构造器或者枚举类型强化Singleton属性
举例1：使用私有构造器
public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} //私有构造器 //other code }
为了保证Singleton类是可序列化的
1）声明加上implents Serializable
2) 所有实例域都是transient
3）提供一个readResolve方法
private Object readResolve() { return INSTANCE; }
举例2：使用枚举
public enum Singleton { INSTANCE; }
第4条：通过私有构造器强化不可实例化的能力
主要用于在写工具类的时候。
public class XXXUtils { private XXXXUtils() { } //other code }
第5条：避免创建不必要的对象
当你应该重用现有对象的时候，不要创建新的对象。
举例1：
m方法会被频繁调用时，会创建n多的String实例。
public String m() { String s = new String("str"); //other code }
改进后，m方法被频繁调用，但是s会被复用。
public String m() { String s = "str"; }
举例2：
求所有Integer的和，因声明为Long sum，而不是long sum，程序将创建约2的31次方个Long实例。
public static void main(String[] args) { Long sum = 0L; for (long i = 0; i < Integer.MAX_VALUE; i++) { sum += i; //这里每次都会创建一个Long实例。要当心无意识的自动装箱。 } System.out.println(sum); }
第6条：消除过期的对象引用
主要讲了内存泄露问题。
举例1：类自己管理内存，易导致内存泄露。
下面是简单的栈实现，程序每次测试都会通过，但是有个隐藏问题——”内存泄露“。
栈先增长，再收缩，栈中弹出的对象不会被当做垃圾回收，即使使用栈的程序不再引用这些对象。
public class Stack { private Object[] elements; private int size; private static final int DEFAULT_INIT_CAPACITY = 16; public Stack() { elements = new Object[DEFAULT_INIT_CAPACITY]; } public void push(Object e) { ensureCapacity(); elements[size++] = e; } public Object pop() { if (size == 0) { throw new EmptyStackException(); } Object result = elements[--size]; //解决内存泄露的方法 //elements[size] = null; 清空过期引用 return result; } }
为何会出现内部泄露？
Stack通过数组保存数组元素，相当于自己管理内存。只要是类自己管理内存，就应该警惕内存泄露问题。
举例2：内存泄露的另一个常见来源是缓存
缓存内存泄露：把对象引用放到缓存中，容易被遗忘，不再有用之后仍留在缓存中。
情形1：只要在缓存外有对某个项的键的引用，该项就有意义。
解决方法：使用WeakHashMap。
（记住只有当缓存项生命周期由该键的外部引用而不是值决定时，WeakHashMap才有意义）
情形2：缓存项生命周期是否有意义，不是很容易确定
解决方法：后台线程定期清理 or 缓存添加新条目时顺便清理(LinkedHashMap.removeEldestEntry()方法)
情形3：更复杂的缓存
解决方法：使用java.lang.ref
举例3：内存泄露的第三个常见来源是监听器和其他回调
比如注册回调，但是没有显式地取消回调。解决方法：保存它们的弱引用(weak ref)，如只将它们保存为WeakHashMap的键。
第7条：避免使用终结方法
终结方法就是finalize()方法。
Java语言规范不保证终结方法会被及时地执行，更不保证一定会被执行。
System.gc()增加了终结方法被执行的机会，但不保证一定会被执行。
