Article-No.01 Effective Java-优快云博客

2019独角兽企业重金招聘Python工程师标准>>>

第2章创建和销毁对象

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

public static Boolean valueOf(boolean paramBoolean) {
    return ((paramBoolean) ? TRUE : FALSE);
}

1）静态工厂方法与构造器不同的优势：

它们有名称，可以见名知意，当一个类需要多个带有相同签名的构造器时，就用静态工厂方法替代构造器，并选择其名称加以区别
不必每次调用它们的时候都创建一个新对象，单例模式实现（判断两个对象是否相等的时候，可以直接用==代替equals()提高性能）
可以返回原返回类型的任何子类型对象

public interface Type {
    public void add(Type type);
    public void delete(int typeId);
    public void update(Type type);
    public Type query(int typeId);
}

/**
 * Type工具类
 * @author admin
 *
 */
public class Types {
    private Types() {
    }
 
    public static Type getType() {
        return new TypeImpl() ;
    }
}

2）静态工厂方法的特点是每次被调用的时候，不一定会返回一个新的实例，利用这一特点，静态工厂方法可以用于创建一下实例：

单例类：只有唯一的实例对象
枚举类：实例数量有限的类
具有实例缓存的类：能将已经创建的实例暂且存放在缓存中的类
具有实例缓存的不可变类：不可变的实例一旦创建，其属性就不会发生改变

3）静态工厂方法缺点：

类如果被定义为私有的构造器，则不能被子类化
静态工厂方法和其他静态方法没有明显区别，用户难以识别哪些静态方法是用来返回类实例的，为了减少这一缺点带来的负面影响，可以在为静态工厂方法命名时尽量遵守约定俗成的规范，当然这不是必需的。

1）valueOf：该方法返回的实例与它的参数具有相同的值，这样的类工厂方法实际上类型转换方法

2）of：代替valueOf，在EnumSet中使用

3）getInstance：返回相同的实例对象

4）newInstance：返回不同的实例对象

5）getType：和getInstance相同，但是在静态工厂方法处于不同的类型返回值使用

6）newType：和newInstance相同，但是在静态工厂方法处于不同的类型返回值使用

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

1）多个构造器参数时，可以采用Builder模式，Builder模式模拟了具有多个可选参数

package cn.guagua.mobile.common.http;

import java.util.Map;

/**
 * 主播信息参数实体类
 * @author shma
 * @date 2014-10-16 11:15:00
 *
 */
public class HttpEntity {

	private String url;
	private String entityName;
	private Map<String, Object> paramMap;
	private REUQEST_TYPE requestType; // 0 : get, 1 : post
	private REQUEST_SERVICE reqService;
	private Map<String, String> header;
	private int timeout;
	
	public enum REUQEST_TYPE {
		GET,
		POST
	};
	
	public enum REQUEST_SERVICE {
		SYNCH,       //同步
		ASYNCH       //异步
	};
	
	private HttpEntity(Builder builder) {
		url = builder.url;
		entityName = builder.entityName;
		paramMap = builder.paramMap;
		requestType = builder.requestType;
		reqService = builder.reqService;
		header = builder.header;
		timeout = builder.timeout;
	}  
	
	public String getUrl() {
		return url;
	}

	public String getEntityName() {
		return entityName;
	}

	public Map<String, Object> getParamMap() {
		return paramMap;
	}

	public REUQEST_TYPE getRequestType() {
		return requestType;
	}

	public REQUEST_SERVICE getReqService() {
		return reqService;
	}

	public Map<String, String> getHeader() {
		return header;
	}

	public int getTimeout() {
		return timeout;
	}

	public static class Builder {
		protected String url;
		protected String entityName;
		protected Map<String, Object> paramMap;
		protected REUQEST_TYPE requestType; // 0 : get, 1 : post
		protected REQUEST_SERVICE reqService;
		protected Map<String, String> header;
		protected int timeout;
		
		public Builder() {
			
		}
		
		public Builder setUrl(String url) {
			this.url = url;
			return this;
		}
		
		public Builder setEntityName(String entityName) {
			this.entityName = entityName;
			return this;
		}
		
		public Builder setParamMap(Map<String, Object> paramMap) {
			this.paramMap = paramMap;
			return this;
		}
		
		public Builder setRequestType(REUQEST_TYPE requestType) {
			this.requestType = requestType;
			return this;
		}

		public Builder setReqService(REQUEST_SERVICE reqService) {
			this.reqService = reqService;
			return this;
		}

		public Builder setHeader(Map<String, String> header) {
			this.header = header;
			return this;
		}

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

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

2）

转载于:https://my.oschina.net/shma1664/blog/315914