静态工厂和建造者模式——EffectiveJava学习笔记

关于静态工厂

1.首先什么是静态工厂：

在类的内部写一个方法，通过这个方法来获得类的实例，而不是在主函数中通过new来获取实例。
如：

public class Pizza{

	int size;
	
	String name;l
	
	public static getPizza(int size , name){
	
	Pizza pizza = new Pizza();
	 pizza.size = siza;
	 pizza.name = name;
	 return pizza;
	}
}

2.为什么用（Effective Java中提到了5个优势）:

（1）他们有名称：如果一个pojo里面有10个属性，使用构造器的话，你得写10个参数来给这个实例进行初始化为了避免空指针异常。如果不是对这个类特别的熟悉，你无法记住这10个参数的先后顺序，比方说第六个参数是给谁赋值来着？很难记忆，而且没有意义。如上例中的披萨，如果把getPizza改成getPizzaWithSizaName。你就能很清楚的了解第几个参数是给谁赋值了。

（2）不必在每次调用他们的时候都创建一个新对象：很多时候外部只需要一个实例，至于他是不是新的就很无所谓。比方说做插入的时候，我已经new了一个学生了，如果还想再插入一条记录的话。就没有必要再去new了。做成单例模式就能节约不少的内存开销。
详情的单例模式说明

（3）它们可以返回原返回类型的任何子类型对象：看如下的例子，我们可以通过Person类来获取它的子类（Cooker）的实例。

public class Person {
	
	public static Person getCooker(){
		return new Cooker();
	}
	public static void main(String[] args) {
		Person person = Person.getCooker();
		System.out.println(person);
	}
}

public class Cooker extends Person {
//Cooker不是厨师的意思这里为了演示方便
	private String name = "厨师";
	@Override
	public String toString() {
		return name;
	}
}

（4）所返回的对象的类可以随着每次调用而发生变化，这取决于静态工厂方法的参数值：暂时的理解：参考上面的返回子类的方法。

（5）方法返回的对象所属的类，在编写包含该静态工厂方法的类时可以不存在。比方说一个服务需要多个服务提供者共同提供，那么如果你缺少某一个服务提供者，你还是可以获得这个类的实例。

3.静态工厂的缺点

（1）为了安全你不会给这个类添加共有的构造函数。但是没有共有或者受保护的构造函数，你就无法将这个类作为父类（无法子类化）。

（2）在API文档中，它不会像构造函数那样被标明出来。你就很难查明他是如果生成一个实例的。

---

关于构造器

如果参数很多，静态工厂和构造器看起来就都不是那么的适合了。你可能有很多参数，但是每个子类很可能有些值就是0，但是构造的时候你还是需要全部写上。

堆叠构造器

重载多个构造函数，一个套一个。两个参数的构造方法里面套用三个参数的构造方法（第三个参数写0）一直到所有参数都被赋值了再将类的属性赋值，很明显他的局限性就是阅读起来很困难。参数够多了以后客户端代码也很难写，如果编写的时候一不小心颠倒了某两个参数的顺序，大概率是不会报错的，但是实际上是有BUG了。

JavaBean模式

用无参的构造方法来构造实例，再用set和get方法对参数进行赋值，对于现阶段来说是自己用的最频繁的模式了。书中有说明

在构造过程中，可能会处于不一致的状态

所以提出了下面的建造者模式。
解释一下工厂模式的优势：比方说我现在需要一个人，类中有各种属性，四肢，帽子，衣服等等大约20个属性。然后我现在需要一个警察，给他佩戴一个警帽，我们看看用JavaBean模式有什么缺点。那么我们先new一个Person类，然后set他的帽子属性为警帽，接下来呢？为了构造出一个警察，你需要去查文档才能知道有那些属性(左手有什么右手有什么穿什么衣服等)是需要赋初值以及赋什么初值的。而这件事情由工厂模式来做会发生什么，你可以在工厂内部就将需要赋初值的属性搞定，然后构造的时候只要传一个警帽的属性，完全不需要去管还有什么属性需要赋初值！光是想想就能知道代码精简了多少。

build模式（建造者模式）

先看一段代码。

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;
	
	@Override
	public String toString() {
		return servingSize+"\t"+fat+"\t"+carbohydrate;
	}
	
	//工厂模式
	public static class Builder{
		private final int servingsSize;
		private final int servings;
		
		private int calories 		= 0;
		private int fat 			= 0;
		private int sodium 			= 0;
		private int carbohydrate 	= 0;
		
		/*
		 * 通过一个build工厂对属性赋值
		 * */
		
		public Builder(int servingSize , int servings){
			this.servings		= servings;
			this.servingsSize	= servingSize;
		}
		
		public Builder calories(int val)
		{ calories = val; 		return this;}	//返回这个builder类的实例
		
		public Builder fat(int val)
		{ fat = val;			return this;}
		
		public Builder sodium(int val)
		{ sodium = val; 		return this;}
		
		public Builder carbohydrate(int val)
		{ carbohydrate = val;	return this;}
		
		public NutritionFacts build(){
			return new NutritionFacts(this);
		}
	}
	
	private NutritionFacts(Builder builder){
		servingSize		= builder.servingsSize;
		servings		= builder.servings;
		calories		= builder.calories;
		fat				= builder.fat;
		sodium			= builder.sodium;
		carbohydrate	= builder.carbohydrate;
	}
	//赋值语句
	NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).calories(100)
				.sodium(35).carbohydrate(27).build();
}

先将所有属性赋值了以后再获得他的实例，用了一个内部类而不是类本身来进行实例化。比方说你想生产一台电脑，你自己也可以生产，自己做芯片，CPU，显卡等东西，再组装起来。而建造者模式就是提供了一个建造电脑的工厂，那里面什么设备都有，你最后可能就是跑过去拿出来就可以了。有效的降低了代码的重复率，甚至于可以自动填充某些域，列入每次创建对象时自动增加序列号。

---