设计模式--工厂模式
总的说来，工厂模式有两种：工厂方法和抽象工厂。
工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化方法推迟到子类。利用工厂方法创建对象，通常需要继承一个类，并覆盖它的工厂方法。
举例如下（还是来自《Head First 设计模式》中的例子）：
1.工厂方法
现在我们要买一个NY风味的Cheese Pizza，那么首先要得到一个生产NY风味的Pizza的工厂，然后点菜（传入需要的风味名称：”cheese“）
PizzaStore nyStore = new NYPizzaStore();
Pizza pizza1 = nyStore.orderPizza("cheese");
NYPizzaStore是生产NY风味Pizza的工厂，它继承自PizzaStore。提供了一个接口抽象方法
abstract Pizza creatPizza(String type)
根据传入的参数，生产相应类型的Pizza。PizzaStore定义如下：
import edu.zju.www.Product.Pizza;;
public abstract class PizzaStore {
protected abstract Pizza creatPizza(String type); //这里提供了一个接口，让子类实现。从而到达了让子类去决定实例化类型的目的！
public Pizza orderPizza(String type){
Pizza pizza ;
pizza = creatPizza(type);
pizza.prepare();
pizza.cut();
pizza.box();
return pizza;
}
}
NYPizza覆盖了：
public Pizza creatPizza
其定义如下：
public class NYPizzaStore extends PizzaStore {
@Override
public Pizza creatPizza(String item) { //这里是具体生产的方法，为了简单起见，只生产一种风味cheese
// TODO Auto-generated method stub
if(item.equals("cheese")){
return new NYStyleCheesePizza();
}else
return null;
}
}
产品是Pizza。
Pizza的定义如下：
import java.util.ArrayList;
public abstract class Pizza {
String name;
String dough;
String sauce;
ArrayList topping = new ArrayList();
public 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 < topping.size();i++){
System.out.println(" " + topping.get(i));
}
}
public void bake(){
System.out.println("baking at 350");
}
public void cut(){
System.out.println("cutting the pizza into dialognal slices");
}
public void box(){
System.out.println("Place the pizza into box");
}
public String getName(){
return name;
}
}
NY风格的CheesePizza继承自Pizza，定义如下：public class NYStyleCheesePizza extends Pizza {
public NYStyleCheesePizza(){
name = "NY Syle Sauce and Cheese Pizza";
dough = "Thin Crust Dough";
sauce = "Marina Sauce";
topping.add("Grated Regginao Cheese");
}
}
运行结果：
preparing NY Syle Sauce and Cheese Pizza
Tossing dough...
Adding sauce...
Adding toppings:
Grated Regginao Cheese
cutting the pizza into dialognal slices
Place the pizza into box
2.抽象工厂
通过抽象工厂所提供的接口，可以创建产品的家族而不要指定具体的类。（抽象工厂提供的接口，就是为子类搭好了框架，所以所有的子类看起来本质上都一样，只是表现形式不一样。）
假设，生产Pizza需要3种原料：Dough, Sauce, Cheese。那么，就可以定义一个抽象工厂：PizzaIngredientFactoy
public interface PizzaIngredientFactoy {
public Dough createDough();
public Sauce createSauce();
public Cheese createCheese();
}
而具体的生产NYPizzaIngredient的工厂NYPizzaIngredientFactoty集成了PizzaIngredientFactoy：
public class NYPizzaIngredientFactoty implements PizzaIngredientFactoy {
@Override
public Dough createDough() {
// TODO Auto-generated method stub
return new DoughNY();
}
@Override
public Sauce createSauce() {
// TODO Auto-generated method stub
return new SauceNY();
}
@Override
public Cheese createCheese() {
// TODO Auto-generated method stub
return new CheeseNY();
}
}
当然，为了完善程序，自己还需要定义Dough, DoughNY, Sauce, SauceNY, Cheese, CheeseNY。（NY就是New york，代表new jork风味的Pizza）
这回Pizza的类定义如下：
public abstract class Pizza {
Dough dough;
Sauce sauce;
Cheese cheese;
public abstract void prepare();
}
具体类CheesePizza定义如下：
注意CheesePizza类使用了一个常用的手法：组合
public class CheesePizza extends Pizza {
PizzaIngredientFactoy ingredientFactory; //注意这里！！！！使用了组合
public CheesePizza(PizzaIngredientFactoy ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println("Preparing.... ");
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
最后，《Head First 设计模式》总结了两个方法的不同（有面试题目问到哦）
相同点：
工厂方法与抽象工厂都负责对象的创建，都是力图将类型的定义延迟到子类中（由子类来决定创建的类型）
不同点：
工厂方法使用继承，而抽象工厂使用组合:
可以看到，具体产品CheesePizza类中有一个Factory;
而在工厂方法中，要创建CheesePizza，首先要在外面自己创造一个Factory,然后调用工厂的创建方法并传入参数。