《java设计模式》：工厂模式

工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类时哪一个。工厂模式把实例化推迟到子类。

工厂模式结构图

在工厂模式中，产品和工厂层次是平行的。

Factory为抽象的创建者，它定义了一个抽象的工厂方法，让子类实现此方法制作产品，创建者通常会包含依赖于抽象产品的代码，而这些抽象产品由子类制造。创建者无需关心在制造那种具体产品。

应用场景

披萨店

披萨基类

import java.util.ArrayList;

public abstract class Pizza {

	String name;
	
	String dough;
	
	String sauce;
	
	ArrayList toppings = new ArrayList();
	
	void prepare()
	{
		System.out.println("Preparing " + name);
		System.out.println("Tossing  dough...");
		System.out.println("Adding sauce...");
		System.out.println("Adding toppings...");
		for(int i =0 ; i < toppings.size();i++)
		{
			System.out.println("  " + toppings.get(i));
		}
	}
	
	void bake()
	{
		System.out.println("Bake for 25 minites at 350 ");
	}
	
	void cut()
	{
		System.out.println("Cutting the pizza into diagonal slices ");
	}
	
	void box()
	{
		System.out.println("Place pizza in official PizzaStore box ");
	}
			
	public String getName()
	{
		return name;
	}
	
}

芝加哥奶酪披萨

public class ChicagoStyleCheesePizza extends Pizza {

	public ChicagoStyleCheesePizza() {
		name = "Chicago Style Deep Dish and Cheese Pizza";
		dough = "Extra Thick Crust Dough";
		sauce = "Plum Tomato Sauce";
		toppings.add("Shredded Mozzarella Cheese");			
	}
	@Override
	void cut() {
		System.out.println("Cutting the pizza into square slices");
	}
}

纽约奶酪披萨

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 abstract class PizzaStore {

	public Pizza orderPizza(String type)
	{
	
		Pizza pizza;
		pizza = createPizza(type);
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		
		return pizza;
	}
	protected abstract Pizza createPizza(String type);
	
}

纽约披萨店

public class NYPizzaStore extends PizzaStore {

	@Override
	protected Pizza createPizza(String type) {
		if(type.equals("cheese"))
		{
			return new NYStyleCheesePizza();
		}
		else
		{
			return null;
		}
	}

}

芝加哥披萨店

public class ChicagoPizzaStore extends PizzaStore {

	@Override
	protected Pizza createPizza(String type) {
		if(type.equals("cheese"))
		{
			return new  ChicagoStyleCheesePizza();
		}
		else
		{
			return null;
		}
	}

}

测试：

public class PizzaTestDrive {

	public static void main(String[] args) {
		PizzaStore nyStore = new NYPizzaStore();
		PizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
		
		Pizza pizza = nyStore.orderPizza("cheese");
		System.out.println("Ethan ordered a " + pizza.getName());
		
		pizza = chicagoPizzaStore.orderPizza("cheese");
		System.out.println("Joel ordered a " + pizza.getName());
		
	}
}

工厂模式将创建对象的代码集中在一个对象或方法中，可以避免代码的重复，提高代码复用率，减低维护成本。在工厂模式中，其核心原则为：依赖倒置原则。

在传统方法中，我们采用如下方法制作披萨：

public  class TraditionalPizzaStore {

	public Pizza createPizza(String style,String type)
	{
		Pizza pizza = null;
		if(style.equals("NY"))
		{
			if(type.equals("cheese"))
			{
				pizza = new NYStyleCheesePizza();
			}
		}
		else if(style.equals("Chicago"))
		{
			if(type.equals("cheese"))
			{
				pizza = new ChicagoStyleCheesePizza();
			}			
		}
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}

}

在代码中实例化两个披萨对象，就是依赖了披萨的具体类。其依赖关系图如下：

传统披萨店依赖于所有的披萨对象，每新增一个披萨种类，必须重新修改PizzaStore的代码，对于任何具体实现的任何改变都会影响到PizzaStore，违反了面向接口编程，而不是面向实现编程的原则。

工厂模式中，依赖关系如下：

在工厂模式中，PizzaStore和具体pizza都依赖抽象的Pizza接口。