【设计模式】HeadFirst设计模式（四）：工厂模式

     设计模式要求我们不应该针对实现编程，是为了降低耦合度，提高可维护性。当程序中出现“new”的时候，就证明程序在实例化一个具体类，所以用的是实现，而不是接口。如果代码绑着具体的类会导致代码更加脆弱，缺乏弹性。比如，需要创建一“个鸡蛋饼”这个对象，首先需要创建一个饼，然后创建一个鸡蛋，再然后把鸡蛋摊在饼上边，然后给饼翻翻，几分钟后就出炉了....（有点饿）。在这种情况下，新对象的建立是一个过程，如果我们需要在这个饼上边抹点辣椒酱，那肯定需要对类进行修改，违反了“对扩展开放，对修改关闭”的设计原则。这样就出现了一个问题：

     如何让客户直接构造出对象的实例，而不用在乎构造对象实例的具体细节？（就比如说，我想吃鸡蛋饼，直接就能买到，不需要知道这个鸡蛋饼如何做出来的）

具体实现：

首先，我们需要知道，工厂模式包含了三种：简单工厂（静态工厂）、工厂方法、抽象工厂。但是简单工厂并不属于GOF的23种设计模式

下边会用制作Pizza的例子来对三个模式进行说明：

假设你有一个Pizza店，并且你有很多种类型的Pizza，那么你会这样写代码：

Pizza orderPizza(String type){
		Pizza pizza;
		
		if(type.equals("chesse")){
			pizza = new CheesePizza();
		}else if(type.equals("greek")){
			pizza = new GreekPizza();
		}else if(type.equals("pepperoni")){
			pizza = new PepperoniPizza();
		}
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}

根据参数传入类型type的不同，实例化不同的Pizza。

但是，你的竞争对象已经在菜单中加入了其它流行风味Pizza：ClamPizza（蛤蜊披萨）、VeggiePizza（素食披萨）。如果你想要赶上他们你就必须在自己的菜单中加入这些风味的披萨，而GreekPizza（希腊披萨）因为卖的不好所以去掉：

很明显的，orderPizza()方法不能够使得对修改关闭，但是我们已经知道哪些会改变，哪些不会改变，就可以使用封装了。

一、简单工厂模式：

要把创建Pizza的代码移动到另一个对象中，由这个新对象专职创建Pizza：

public class SimplePizzaFactory {
	public Pizza createPizza(String type) {
		Pizza pizza = null;

		if (type.equals("cheese")) {
			pizza = new CheesePizza();
		} else if (type.equals("pepperoni")) {
			pizza = new PepperoniPizza();
		} else if (type.equals("clam")) {
			pizza = new ClamPizza();
		} else if (type.equals("veggie")) {
			pizza = new VeggiePizza();
		}
		return pizza;
	}
}

问题：这么做似乎是把问题搬到另一个对象罢了？似乎没有什么好处？

答：SimplePizzaFactory可以有许多的客户，虽然目前仅仅只有orderPizza()方法是它的客户，但是在以后的扩展过程中可能会有很多个客户（但是如果把createPizza()这个方法放入到orderPizza()方法中的话，它只可能为orderPizza()一个服务）。所以，把创建Pizza的代码包装进一个类后，当以后实现改变的话，只需要修改这个类即可。我们正需要做的就是把实例化的过程，从客户的代码中删除。

缺点：因为是静态的，不能够通过继承来改变创建方法的行为。

下边，我们把其它的类写出来：

PizzaStore：是SimplePizzaFactory工厂类的“客户”，PizzaStor通过工厂类取得Pizza的实例

public class PizzaStore {
	SimplePizzaFactory factory;

	public PizzaStore(SimplePizzaFactory factory) {
		this.factory = factory;
	}

	public Pizza orderPizza(String type) {
		Pizza pizza;

		pizza = factory.createPizza(type);

		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();

		return pizza;
	}
}

Pizza：工厂的产品

abstract public class Pizza {
	String name;
	String dough;
	String sauce;
	ArrayList toppings = new ArrayList();

	public String getName() {
		return name;
	}

	public void prepare() {
		System.out.println("Preparing " + name);
	}

	public void bake() {
		System.out.println("Baking " + name);
	}

	public void cut() {
		System.out.println("Cutting " + name);
	}

	public void box() {
		System.out.println("Boxing " + name);
	}

	public String toString() {
		StringBuffer display = new StringBuffer();
		display.append("---- " + name + " ----\n");
		display.append(dough + "\n");
		display.append(sauce + "\n");
		for (int i = 0; i < toppings.size(); i++) {
			display.append(toppings.get(i) + "\n");
		}
		return display.toString();
	}
}

CheesePizza：

public class CheesePizza extends Pizza {
	public CheesePizza() {
		name = "Cheese Pizza";
		dough = "Regular Crust";
		sauce = "Marinara Pizza Sauce";
		toppings.add("Fresh Mozzarella");
		toppings.add("Parmesan");
	}
}

VeggiePizza：

public class VeggiePizza extends Pizza {
	public VeggiePizza() {
		name = "Veggie Pizza";
		dough = "Crust";
		sauce = "Marinara sauce";
		toppings.add("Shredded mozzarella");
		toppings.add("Grated parmesan");
		toppings.add("Diced onion");
		toppings.add("Sliced mushrooms");
		toppings.add("Sliced red pepper");
		toppings.add("Sliced black olives");
	}
}

ClamPizza：

public class ClamPizza extends Pizza {
	public ClamPizza() {
		name = "Clam Pizza";
		dough = "Thin crust";
		sauce = "White garlic sauce";
		toppings.add("Clams");
		toppings.add("Grated parmesan cheese");
	}
}

写一个Main类：PizzaTestDrive

public class PizzaTestDrive {

	public static void main(String[] args) {
		SimplePizzaFactory factory = new SimplePizzaFactory();
		PizzaStore store = new PizzaStore(factory);

		Pizza pizza = store.orderPizza("cheese");
		System.out.println("We ordered a " + pizza.getName() + "\n");

		pizza = store.orderPizza("veggie");
		System.out.println("We ordered a " + pizza.getName() + "\n");
	}
}

把UML类图画出来了：

二、工厂方法模式

特点：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类

现在，大家都希望能够在自家附近加盟你开的披萨店（其实就是想用你的招牌在他们那里开店啦）。但是，每个区域都会有差异，每家加盟店都想要提供不同风味的比萨（比方说纽约、芝加哥、加州），你想这样做：

//纽约风味的素食Pizza
NYPizzaFactory nyFactory = new NYPizzaFactory();
PizzaStore nyStore = new PizzaStore(nyFactory);
nyStore.orderPizza("Veggie");

//芝加哥风味的素食Pizza
ChicagePizzaFactory chicagoFactory = new ChicagePizzaFactory();
PizzaStore chicagoStore = new PizzaStore(chicagoFactory);
chicagoStore.orderPizza("Veggie");

问题：但是，在推广你的方法的时候，别的加盟店的确是采用你的工厂创建比萨，但是其他部分却开始此采用他们自创的流程：烘烤的做法有差异、不要切片、使用其他厂商的盒子等等。

有一种做法可以让比萨制作活动局限于PizzaStore类，而同时又能让这些加盟店依然可以自由的制作本地区域的风味：

            把createPizza()方法放回到PizzaStore中，不过要把它设置成“抽象方法”：（原本是由一个对象负责所有具体类的实例化，现在通过对PizzaStor做一些转变，变成由一群子类来负责实例化）

声明一个工厂类：

public abstract class PizzaStore {
	//把createPizza()方法设置成抽象的，由子类做决定
	abstract Pizza createPizza(String item);
	
	public Pizza orderPizza(String type) {
		Pizza pizza = createPizza(type);
		System.out.println("--- Making a " + pizza.getName() + " ---");
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}
}

然后声明两个具体工厂类：NYPizzaStore、ChicagoPizzaStore：

public class NYPizzaStore extends PizzaStore {
	Pizza createPizza(String item) {
		if (item.equals("cheese")) {
			return new NYStyleCheesePizza();
		} else if (item.equals("veggie")) {
			return new NYStyleVeggiePizza();
		} else if (item.equals("clam")) {
			return new NYStyleClamPizza();
		} else if (item.equals("pepperoni")) {
			return new NYStylePepperoniPizza();
		} else return null;
	}
}

public class ChicagoPizzaStore extends PizzaStore {
	Pizza createPizza(String item) {
        	if (item.equals("cheese")) {
            		return new ChicagoStyleCheesePizza();
        	} else if (item.equals("veggie")) {
        	    	return new ChicagoStyleVeggiePizza();
        	} else if (item.equals("clam")) {
        	    	return new ChicagoStyleClamPizza();
        	} else if (item.equals("pepperoni")) {
            		return new ChicagoStylePepperoniPizza();
        	} else return null;
	}
}

我们需要建立一个Pizza实体类：

public abstract class Pizza {
	String name; //名称
	String dough; //面团类型
	String sauce; //酱料
	ArrayList toppings = new ArrayList(); //作料

	void prepare() {
		System.out.println("准备 " + name);
		System.out.println("揉面团...");
		System.out.println("添加酱料...");
		System.out.println("添加作料: ");
		for (int i = 0; i < toppings.size(); i++) {
			System.out.println("   " + toppings.get(i));
		}
	}
	void bake() {
		System.out.println("烘烤25分钟");
	}
	void cut() {
		System.out.println("把Pizza对角切片");
	}
	void box() {
		System.out.println("把Pizza装盒子");
	}
	public String getName() {
		return name;
	}
}

然后需要一些具体的子类，下边定义两个子类：纽约风味的芝士披萨（NYStyleCheesePizza）、芝加哥风味的芝士披萨(ChicageStyleCheesePizza)

public class NYStyleCheesePizza extends Pizza {
	public NYStyleCheesePizza() { 
		name = "NY Style Sauce and Cheese Pizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
 
		toppings.add("Grated Reggiano Cheese");
	}
}

public class ChicagoStyleCheesePizza extends Pizza {
	public ChicagoStyleCheesePizza() { 
		name = "Chicago Style Deep Dish Cheese Pizza";
		dough = "Extra Thick Crust Dough";
		sauce = "Plum Tomato Sauce";
 
		toppings.add("Shredded Mozzarella Cheese");
	}
	//可以覆盖cut()方法
	void cut() {
		System.out.println("Cutting the pizza into square slices");
	}
}

我们把UML类图画出来：

如果我们需要一个纽约风味的芝士披萨，我们应该怎么做：

(1) 需要一个纽约比萨店：PizzaStore nyPizzaStore = new NYPizzaStore();

(2) 下订单：nyPizzaStore.orderPizza("cheese");

(3) orderPizza()方法调用createPizza()方法：Pizza pizza = createPizza("cheese");
(4) 最后经过：pizza.prepare()、pizza.bake()、pizza.cut()、pizza.box()才能完成Pizza

抽象工厂（放在了下一篇）