Effective Java 读书笔记（一）：创建和销毁对象

1 构造器 => 静态工厂方法

（1）优势

• 静态工厂方法有名字
• 静态工厂方法不必在每次被调用时都产生一个新的对象
• 静态工厂方法能返回原返回类型的任意子类型的对象
• 静态工厂方法根据调用时传入的不同参数而返回不同类的对象
• 静态工厂方法返回对象的类不需要存在(SPI架构)

（2）限制

• 没有公有或者保护构造方法的类不能子类化（但是可以鼓励我们使用组合模式，而不是继承模式）
• 静态工厂方法难以发现

（3）常用静态工厂方法命名

• from：传入单个参数，返回该类型实例

Date d = Date.from(instant);

• of：传入多个参数，返回一个包含这些参数的该类型实例

Set<Rank> faceCards = EnumSet.of(JACK, QUEEN, KING);

• valueOf：from和of的替换方案

BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);

• instance or getInstance：创建一个由参数（如果有的话）描述的实例

StackWalker luke = StackWalker.getInstance(options);

• create or newInstance：类似instance或getInstance, 但保证每次调用都返回新实例

Object newArray = Array.newInstance(classObject, arrayLen);

• getType：类似getInstance，但一般在工厂方法包含在不同类的情况下使用。Type是工厂方法返回的对象的类型。

FileStore fs = Files.getFileStore(path);

• newType：类似于newInstance，但一般在工厂方法包含在不同类的情况下使用。

BufferedReader br = Files.newBufferedReader(path);

• type：getType和newType简洁的替换方式

List<Complaint> litany = Collections.list(legacyLitany);

2 构造器 => 构建者

（1）问题

public class NutritionFacts {
    private final int servingSize; // (mL) required
    private final int servings;    // (per container) required
    private final int calories;    // (per serving) optional
    private final int fat;         // (g/serving) optional
    private final int sodium;      // (mg/serving) optional
    private final int carbohydrate; // (g/serving) optional
    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }
    public NutritionFacts(int servingSize, int servings, int calories) {
        this(servingSize, servings, calories, 0);
    }
    public NutritionFacts(int servingSize, int servings, int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }
    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }
    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium,
        int carbohydrate) {
        this.servingSize = servingSize; this.servings = servings;
        this.calories = calories
        this.fat = fat
        this.sodium = sodium
        this.carbohydrate = carbohydrate;
    }
}

• 构造器方法数量迅速膨胀，因为有大量的可选项
• 可伸缩构造器(使用可变参数)是可行，只是当有很多参数时，会让客户端代码很难编写，而且代码也很难阅读。

（2）替代方案：JavaBeans模式

public class NutritionFacts {
    private int servingSize = -1; // Required; no default value
    private int servings = -1; // Required; no default value
    private int calories = 0;
    private int fat = 0;
    private int sodium = 0;
    private int carbohydrate = 0;
    public NutritionFacts() {}
    // Setters
    public void setServingSize(int val) {
        servingSize = val;
    }
    public void setServings(int val) {
        servings = val;
    }
    public void setCalories(int val) {
        calories = val;
    }
    public void setFat(int val) {
        fat = val;
    }
    public void setSodium(int val) {
        sodium = val;
    }
    public void setCarbohydrate(int val) {
        carbohydrate = val;
    }
}

缺点：

• 构造过程被分到了多个调用中，一个JavaBean在其构造过程中可能处于不一致的状态。

• 类无法仅仅通过检查构造器参数的有效性来保证一致性。

（3）替代方案：Builder模式

• 例1

// Builder Pattern
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 {
        // Required parameters
        private final int servingSize;
        private final int servings;
        // Optional parameters - initialized to default values
        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){
            calories = val; return this;
        }
        public Builder fat(int val){
            fat = val; return this;
        }
        public Builder sodium(int val){
            sodium = val; return this;
        }
        public Builder carbohydrate(int val){
            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;
    }
}
// 使用
NutritionFacts cocaCola = new NutritionFacts.Builder(240，8)
                                            .calories(100)
                                            .sodium(35)
                                            .carbohydrate(27)
                                            .build();

• 例2

public abstract class Pizza {
    public enum Topping {
        HAM, MUSHROOM, ONION, PEPPER,SAUSAGE
    }
    final Set<Topping> toppings;
    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings =
        EnumSet.noneOf(Topping.class);
        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }
        abstract Pizza build();
        protected abstract T self();
    }
    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone(); // See Item 50
    }
}
public class NyPizza extends Pizza {
    public enum Size {
        SMALL, MEDIUM, LARGE
    }
    private final Size size;
    public static class Builder extends Pizza.Builder<Builder> {
        private final Size size;
        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }
        public NyPizza build() {
            return new NyPizza(this);
        }
        protected Builder self() {
            return this;
        }
    } 
    private NyPizza(Builder builder) {
        super(builder);
        size = builder.size;
    }
} 
NyPizza pizza = new NyPizza.Builder(SMALL)
    					.addTopping(SAUSAGE)
    					.addTopping(ONION).build();

优势：

• builder能拥有多个可变参数(例1)
• builder能将传入到不同方法里的参数聚合起来然后传入单个域里(例2)

缺点：

• 多创建一个Builder对象的内存开销

3 使用枚举强化单例模式

（1）饿汉

public class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() {}
    public void leaveTheBuilding() {}
}
public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    private Elvis() {}
    public void leaveTheBuilding() {} 
    public static Elvis instance(){
        return INSTANCE;
    }
}

（2）内部类

public class Elvis {
    private Elvis() {}
    public void leaveTheBuilding() {} 
    // 通过类加载机制来保证线程安全
    private static class Holder{
        private static final Elvis INSTANCE = new Elvis();
    }
    public static Elvis instance(){
        return Holder.INSTANCE;
    }
}

（3）双重检验锁

public class Elvis {
    private Elvis() {}
    public void leaveTheBuilding() {} 
    private static volatile Elvis INSTANCE;
    public static Elvis instance(){
        if(INSTANCE == null){
            synchronized(Elvis.class){
                if (INSTANCE == null) {
           			INSTANCE = new Elvis();
      			}
            }
        }
        return INSTANCE;
    }
}

（4）枚举

public enum Elvis {
    INSTANCE;
    public void leaveTheBuilding() {}
}

（5）总结

• 第2、3种具备懒加载

• 第4种具备禁止反序列化创建对象问题

• 第1~3种如果实现了Serializable接口的补偿措施

  // 方法1
  private static Class getClass(String classname) throws ClassNotFoundException {
  	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  	if(classLoader == null)
           classLoader = Singleton.class.getClassLoader();     
        return (classLoader.loadClass(classname));
     }
  }  
  // 方法2
  // 重写readReslove方法，需要将所有成员变量声明为transient
  private Object readResolve() {
      return INSTANCE;
  }
  

参考：

• 单例模式的七种写法

4 私有化构造器强化不可实例化的能力

public class UtilityClass {
	// Suppress default constructor for noninstantiability
    private UtilityClass() {
        throw new AssertionError();
    }
	 // Remainder omitted
}

5 优先使用依赖注入而不是硬连接资源

静态工具类和Singleton对于类行为需要被底层资源参数化的场景是不适用的。

（1）构造器注入

public class SpellChecker {
    private final Lexicon dictionary; // 所需的底层资源
    public SpellChecker(Lexicon dictionary) {
        this.dictionary = Objects.requireNonNull(dictionary);
    } 
    public boolean isValid(String word) { ... }
    public List<String> suggestions(String typo) { ... }
}

（2）Setter注入

public class SpellChecker{
    private Lexicon dictionary; // 所需的底层资源
    void setDictionary(Lexicon dictionary){
        this.dictionary = dictionary;
    }
    public boolean isValid(String word) { ... }
    public List<String> suggestions(String typo) { ... }
}

（3）接口注入

public interface DictionaryDependent{
    void setDependence(Lexicon dictionary);
}
public class SpellChecker implement DictionaryDependent{
    private Lexicon dictionary; // 所需的底层资源
    void setDependence(Lexicon dictionary){
        this.dictionary = dictionary;
    }
    public boolean isValid(String word) { ... }
    public List<String> suggestions(String typo) { ... }
}

参考：

• 依赖注入的三种实现

6 避免创建不必要的对象

• String s = "bikini"; ====> String s = new String("bikini");
• Boolean.valueOf(String) ：内部只维护了两个对象TRUE和FALSE
• 判断是否为数字

// 每次都生成Pattern对象，造成内存浪费
static boolean isRomanNumeral(String s) {
    return s.matches("^(?=.)M*(C[MD]|D?C{0,3})" + "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
}
public class RomanNumerals {
    private static final Pattern ROMAN = Pattern.compile("^(?=.)M*(C[MD]|D?C{0,3})"
                + "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
    static boolean isRomanNumeral(String s) {
        return ROMAN.matcher(s).matches();
    }
}

• Map.keySet()：每次返回同一个实例，懒加载模式
• 注意自动装箱问题
• 尽量不要维护对象池，除非对象创建开销太大，如：JDBC数据库连接池

7 消除过时的对象引用

（1）内存泄漏存在情况与解决

• 一个类自己管理它的内存(没用的对象没有置空)：显式置null
• 缓存相关：
  • 设置淘汰策略：设置超时清除
  • 自制回收线程
  • 内存占用做限制
  • 使用WeakHashMap容器
• 监听器相关：
  • 使用WeakHashMap容器

（2）WeakHashMap的实现原理

• Entry继承WeakReference类：下一次垃圾回收就会回收掉该对象
• WeakHashMap内部一个ReferenceQueue：被回收的对象将放入该队列中
• 任何对WeakHashMap的操作都会进行一次同步操作：ReferenceQueue与Entry[]的同步操作，把Entry过期对象清除，ReferenceQueue清空。

// 回收操作和把对象放入引用队列由JVM处理，WeakHashMap只需要创建WeakReference时，把ReferenceQueue放入即可
// 同步操作：该方法被WeakHashMap中的所有操作涉及，代表只要进行操作就会进行同步，可能你会担心性能问题，但是实际上如果queue中没有数据时，直接就返回了。
private void expungeStaleEntries() {
    // 循环清除queue中的元素
    for (Object x; (x = queue.poll()) != null; ) {
        // 防止并发
        synchronized (queue) {
            @SuppressWarnings("unchecked")
            Entry<K,V> e = (Entry<K,V>) x;
            int i = indexFor(e.hash, table.length);
            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next;
                    else
                        prev.next = next;
                    // 协助GC操作，清除数组中的元素
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

8 避免使用finalize方法

• finalize的调用时机无法把握

  • finalizer线程优先级低，可能还没回收就发生OOM异常
  • System.gc也无法保证一定会执行

• 导致严重的性能损失

• 类暴露于终结方法攻击：

  • 在终结过程中若有未被捕获的异常抛出，则抛出的异常会被忽略，而且该对象的终结过程也会终止。
  • 当构造器或者序列化中抛出异常，恶意子类的终结方法可以运行在本应夭折的只构造了部分的对象上(强行救活父类对象)。此时子类就可以调用该对象上的任意方法，但实际上该对象应该不存在才对。
  • final类能免疫于此类攻击，因为没有类能对final类进行恶意继承。
  • 为了防止非final类遭受终结方法攻击，我们可以写一个什么都不做而且是final的终结方法。

• 替代方案：继承AutoCloseable接口，close方法在被关闭后还被调用，就要抛出一个IllegalStateException异常。

public class Room implements AutoCloseable {
    private static final Cleaner cleaner = Cleaner.create();
    // Resource that requires cleaning. Must not refer to Room!
    private static class State implements Runnable {
        int numJunkPiles;
        // Number of junk piles in this room
        State(int numJunkPiles) {
            this.numJunkPiles = numJunkPiles;
        }
        // Invoked by close method or cleaner
        @Override
        public void run() {
            System.out.println("Cleaning room");
            numJunkPiles = 0;
        }
    }
    // The state of this room, shared with our cleanable
    private final State state;
    // Our cleanable. Cleans the room when it’s eligible for gc
    private final Cleaner.Cleanable cleanable;
    public Room(int numJunkPiles) {
        state = new State(numJunkPiles);
        cleanable = cleaner.register(this, state);
    }
    @Override
    public void close() {
        cleanable.clean();
    }
}

9 优先使用try-with-resources而不是try-finally

• try-finally

static void copy(String src, String dst) throws IOException {
    InputStream in = new FileInputStream(src);
    try {
        OutputStream out = new FileOutputStream(dst);
        try {
            byte[] buf = new byte[BUFFER_SIZE];
            int n;
            while ((n = in.read(buf)) >= 0)
                out.write(buf, 0, n);
        } finally {
            out.close();
        }
    } finally {
        in.close();
    }
}

• try-with-resources

static void copy(String src, String dst) throws IOException {
    try (
        InputStream in = new FileInputStream(src);
        OutputStream out = new FileOutputStream(dst)
    ) {
        byte[] buf = new byte[BUFFER_SIZE]; int n;
        while ((n = in.read(buf)) >= 0)
            out.write(buf, 0, n);
    }
}