《EffctiveJava》建立和销毁对象

建立和销毁对象

用静态工厂方法代替构造器

相比构造器的优势：

• 有名称：能够更明确方法的功能；
• 没必要在调用时重复建立实例：使不可变类预先建立实例，或将实例缓存起来，避免重复建立对象，提升性能。
• 返回原返回类型的子类型的对象。
• 在建立参数化类型实例时，代码更简洁

  Map<String, List<String>> map = new HashMap<String, List<String>>();
  // 用静态工厂方法实现
  Map<String, String> map = HashMap.newInstence();

相比构造器的缺点：

• 类若是不含共有的或者受保护的构造器，将不能被子类化。
• 与其余的静态方法没任何区别。
  静态工厂方法的一些命名习惯
  – valueOf：类型转换方法
  – of：更简洁的替代，在EnumSet中使用并流行起来
  – getInstance：对于Singleton来讲，该方法没有参数，只会返回一个实例。
  – newInstance：与getInstance同样，但newInstance可以确保每一个新实例与其余实例不一样。
  – getType：像getInstance同样，返回对象类型
  – newType：想newInstance同样，返回对象类型

综上：构造器和静态工厂方法各有优缺点，优先使用静态工厂方法。

遇到多个构造器参数时要考虑用构建器

Builder模式：利用多个builder构建多个对象。推荐在多参数且参数大多数都是可选的的状况下使用。

• 优势：易于阅读和编写，比JavaBean更安全。
• 缺点：比重叠构造器冗长。

Builder模式示例：

public class NutritionFacts {

    private final int servingSize;

    private final int servings;

    private final int colorings;

    private final int fat;

    private final int sodium;

    private final int carbohydrate;

    public static class Builder {
        // 必须的
        private int servingSize = 0;

        private int servings = 0;

        // 非必须的
        private int colorings = 0;

        private int fat = 0;

        private int sodium = 0;

        private int carbohydrate = 0;

        public Builder(int servingSize, int servings) {
            this.servings = servings;
            this.servingSize = servingSize;
        }

        public Builder calories(int colorings) {
            this.colorings = colorings;
            return this;
        }

        public Builder carbohydrate(int carbohydrate) {
            this.carbohydrate = carbohydrate;
            return this;
        }

        public Builder sodium(int sodium) {
            this.sodium = sodium;
            return this;
        }

        public Builder fat(int fat) {
            this.fat = fat;
            return this;
        }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        this.servingSize = builder.servingSize;
        this.servings =  builder.servings;
        this.colorings =  builder.colorings;
        this.fat =  builder.fat;
        this.sodium =  builder.sodium;
        this.carbohydrate =  builder.carbohydrate;
    }
}

调用：

NutritionFacts nutritionFacts = new NutritionFacts.Builder(1, 2)
 				.calories(3).carbohydrate(4).fat(5).sodium(6)
                .build();

用私有构造器或枚举类型强化Singleton属性

Singleton是指仅仅被实例化一次的类。Singleton一般被用来表示那些本质上惟一的系统组件，例如窗口管理器或文件系统。

方式一：

public class Elvis {

    private Elvis() {
        // 初始化相关操做
    }

    public static final Elvis INSTANCE = new Elvis();

    public void leaveTheBuilding() {
        // ...
    }
}

使用：

Elvis.INSTANCE;

方式二：

public class Elvis {

    private Elvis() {
        // 初始化相关操做
    }
    private static final Elvis INSTANCE = new Elvis();

    public static Elvis getInstance() {
        return INSTANCE;
    }

}

使用：

Elvis.getInstance();

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

一些工具类不但愿被实例化，实例化对它没有任何意义。

public class UtilityClass {

    /**
     * 私有构造方法，保证在任何状况下都不会被实例化
     */
    private UtilityClass() {
        // 防止在当前类调用构造方法
        throw new AssertionError();
    }

    public static boolean empty(String message) {
        if (message == null || "".equals(message)) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }
}

使用：

UtilityClass.empty("hello Word");

避免建立没必要要的对象

• 正确使用String
  反例：

String s  = new String("hello");	// hello原本就是字符串

正确：

String s = "hello";

• 自动装箱
  优先使用基本类型。

消除过时的对象引用

通常而言，只要类是本身管理内存，就应该警戒内存泄漏的问题。

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) {
        ensureCapacity();
        elements[size ++] = e;
    }

    public Object pop() {
        if (size == 0) {

        }
        Object e = elements[--size];
        elements[size] = null;
        return e;
    }

    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size+1);
        }
    }
}

避免使用终结方法

try finally