工厂模式

工厂模式包括二种：工厂方法和抽象工厂。二者都是让子类决定该创建的对象是什么，

来达到将对象创建的过程封装的目的。但二者略有不同，工厂方法是通过继承来实现，

而抽象工厂是通过组合来实现的。

首先不考虑调料的不同的情况下，随时会有Pizza联盟店加入进来。Pizza联盟店地址不

同，当地的风俗和口味也会不一样。因此Pizza联盟店会提供相应口味的Pizza。工厂方

法模式即在抽象类PizzaStore中提供创建产品的抽象方法，然后让各个地方的Pizza店

继承抽象类PizzaStore,实现抽象方法，自己选择创建什么类型的产品。

实现图如下：

实现代码如下：

Pizza类：

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

　　

ChicagoStyleCheesePizza类（Pizza具体类）：

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 Mozzrella Cheese");
    }

    public void cut()
    {
    System.out.println("Cutting the pizza into square slices");
    }

}

　　

NYStyleCheesePizza类（Pizza具体类）：

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");
    }
}

　　

PizzaStore类（Pizza联盟店基类，所有具体联盟店均继承该基类）

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

　　

ChicagoPizzaStore类（Pizza联盟店）：

public class ChicagoPizzaStore extends PizzaStore{

    @Override
    public Pizza createPizza(String type) {
    // TODO Auto-generated method stub
    if(type.equals("cheese"))
    {
    return new ChicagoStyleCheesePizza();
    }
    else if(type.equals("clam"))
    {
    return new ChicagoStyleClamPizza();
    }
    else if(type.equals("pepperoni"))
    {
    return new ChicagoStylePepperoniPizza();
    }
    else if(type.equals("veggie"))
    {
    return new ChicagoStyleVeggiePizza();
    }
    else
    {
    return null;
    }
    }

}

　　

NYPizzaStore类（Pizza联盟店）：

public class NYPizzaStore extends PizzaStore{

    @Override
    public Pizza createPizza(String type) {
    // TODO Auto-generated method stub
    if(type.equals("cheese"))
    {
    return new NYStyleCheesePizza();
    }
    else if(type.equals("clam"))
    {
    return new NYStyleClamPizza();
    }
    else if(type.equals("pepperoni"))
    {
    return new NYStylePepperoniPizza();
    }
    else if(type.equals("veggie"))
    {
    return new NYStyleVeggiePizza();
    }
    else
    {
    return null;
    }
    }

}

　　

测试类：

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

　　

 纽约使用一组原料，而芝加哥使用另一组原料。现在，我们要建造一个工厂来生产原料，

这个工厂将负责创建原料家族中的每一种原料。也就是说，工厂将需要生产面团、酱料、

芝士等。使用抽象工厂模式（采用组合而不是继承），先为工厂定义一个接口，这个接口

负责创建所有的原料。实现图如下：