《effective in java》 阅读笔记1 -创建和销毁对象

阅读总结。

 

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

   优点：

   1.1 静态工厂方法有名称，比较好理解方法的含义。

   1.2 静态工厂可以返回单例对象。

   1.3 静态工厂方法可以返回任何父类型的子类型对象（比如下面的服务提供者框架中展示的）。

   

package effective.java.chapter1;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author E-mail: [e-mail]
 * @date  : 2013-2-27 上午10:29:14
 * 
 */
public class Services {
	
	private static final Map<String,Provider> providers = new ConcurrentHashMap<String, Provider>();
	private static final String DEFAULT_PROVIDER_NAME = "<def>";
	
	public static void initProviders(String name,Provider provider){
		providers.put(name, provider);
	}
	
	public static void  initProviders(Provider p) {
		initProviders(DEFAULT_PROVIDER_NAME, p);
	}
	
	public static Service getServiceInstance(String name) {
		Provider p = providers.get(name);
		if(p == null){
			throw new IllegalArgumentException("no provider register with name : "+name);
		}
		return p.provider();
	}
	
	public static Service getServiceInstance(){
		return providers.get(DEFAULT_PROVIDER_NAME).provider();
	}
	
	
}

 

 

 

package effective.java.chapter1;
/**
 * @author E-mail: [e-mail]
 * @date  : 2013-2-27 上午10:28:46
 * 
 */
public interface Provider {
	
	Service provider();
	
}

 

package effective.java.chapter1;
/**
 * @author E-mail: [e-mail]
 * @date  : 2013-2-27 上午10:28:20
 * 
 */
public interface Service {
	
	void service();
}

 

 

服务提供者框架中存在三个部分：

1.服务提供者（provider）：注册服务，需要使用的服务在这个类里面注册。

2.服务接口（service）：对外提供的服务，客户端调用这个接口就可以执行相应的服务。

3.服务访问api(services)：客户端用来获取服务的实例。

 

1.4 创建参数化实例的时候，代码更简洁：

import com.google.common.collect.Maps;

Map<String,String> maps = Maps.newHashMap();

 

2.构造函数中参数较多的时候，可以考虑使用build模式

package desigenPattern.factory;
/**
 * @author E-mail: [e-mail]
 * @date  : 2013-2-21 上午10:35:53
 * 
 * Build 构造器模式
 * 
 * build 构造器模式： 使用内部静态类
 * 
 * 当类的构造器或者静态工厂中有多个参数，采用构造器模式不错
 * 
 */
public class Computer {

	private String name;
	private String type;
	private double screenSize;
	private String produceDate;
	private double price;
	
	public static class Build{
		private String name;
		private String type;
		private double screenSize;
		private String produceDate;
		private double price;
		
		Build(String name,String type){
			this.name = name;
			this.type = type;
		}
		
		public Build screenSize(double size) {
			this.screenSize = size;
			return this;
		}
		
		public Build produceDate(String date) {
			this.produceDate = date;
			return this;
		}
		
		public Build price(double price) {
			this.price = price;
			return this;
		}
		
		public Computer build(){
			return new Computer(this);
		}
		
	}
	
	private Computer(Build build) {
		this.name = build.name;
		this.type = build.type;
		this.screenSize = build.screenSize;
		this.produceDate = build.produceDate;
		this.price = build.price;
	}
	
	@Override
	public String toString() {
		return "[computer name = "+name+" type = "+type+" screenSize = "+screenSize+" price "+
				price+" produceDate "+produceDate+"]";
	}
	
}

 

3.使用私有构造器、或者枚举强化单例属性。

 

4.通过私有构造器，强化不能实例化能力。（比如一些工具类uitl就不需要实例化）

 

5.避免创建不必要的对象。（要优先使用基本类型而不是装箱基本类型，避免无意识的装箱）

 

 

6.消除过期引用：（一般而言只要类自己管理内存就要考虑这个问题）。

 

7.避免使用finalizer方法。