对象的创建和销毁

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

• 静态工厂方法的名字使得调用者更容易明白构造的意图,
• 静态工厂方法可以控制实例的创建数量,以提升性能.

代码示例:

public static Boolean valueOf(boolean b) {

return b ? Boolean.TRUE : Boolean.FALSE;

}

当构造参数很多的时候考虑使用建造者(模式)

• 建造者使得构造的代码编写更为自然,同时保证了构造的一次性,
• 建造者能够满足实例构造之后的不变性,这是setter方法无法保证的,
• 一般而言，建造者适用于有四个或以上的可选参数的场景下使用.

代码示例:

// 原始

public class NutritionFacts {

	private final int servingSize; // (mL)  required

	private final int servings; // (per container) required

	private final int calories; //  optional

	private final int fat; // (g) optional

	private final int sodium; // (mg) optional

	private final int carbohydrate; // (g)   optional



	...



	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;

	}

}

// 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 carbohydrate = 0;

		private int sodium = 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 carbohydrate(int val)

		{ carbohydrate = val; return this; }



		public Builder sodium(int val)

		{ sodium = 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;

	}

}

用枚举实现单例(模式)

• 尽管通过private可以保证不能通过new来调用构造器,但通过反射机制可以绕过这一限制.

代码示例:

// Enum singleton - the preferred approach

public enum Elvis {

	INSTANCE;

	public void leaveTheBuilding() { ... }

}

避免创建不必要的对象

• 可以重用对象的时候,不要创建它,
• 考虑值不变的对象在static语句中创建,

代码示例:

public class Person {

	private final Date birthDate;

	// Other fields, methods, and constructor omitted

	

	// DON'T DO THIS!

	public boolean isBabyBoomer() {

		// Unnecessary allocation of expensive object

		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;

	}

}

class Person {

	private final Date birthDate;

	// Other fields, methods, and constructor omitted

	/**

	* The starting and ending dates of the baby boom.

	*/

	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 boolean isBabyBoomer() {

		return birthDate.compareTo(BOOM_START) >= 0 &&

		birthDate.compareTo(BOOM_END)   <  0;

	}

}

• 谨防自动包装(autoboxing),这会产生大量包装类的实例

代码示例:

// Hideously slow program! Can you spot the object creation?

public static void main(String[] args) {

	Long sum = 0L;

	for (long i = 0; i < Integer.MAX_VALUE; i++) {

		sum += i;

	}

	System.out.println(sum);

}

清除过时的对象引用

• 即时清除过时对象的引用,能够促进对象被垃圾回收,从而避免内存泄漏,

代码示例:

// Can you spot the "memory leak"?

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)

		throw new EmptyStackException();

		return elements[--size];

	}

	/**

	* Ensure space for at least one more element, roughly

	* doubling the capacity each time the array needs to grow.

	*/

	private void ensureCapacity() {

		if (elements.length == size)

		elements = Arrays.copyOf(elements, 2 * size + 1);

	}

}

public Object pop() {

	if (size == 0)

	throw new EmptyStackException();

	Object result = elements[--size];

	elements[size] = null; // Eliminate obsolete reference

	return result;

}

• 内存泄漏的三大来源
  • 类自我管理内存
  • 缓存
  • 监听,回调中的引用

避免使用finalize()

• finalize()是不可预知的,经常是危险的,通常是没必要的