对象的创建和销毁

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

代码示例:

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()是不可预知的,经常是危险的,通常是没必要的
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值