设计模式----抽象工厂模式

接到工厂讲，现在披萨店需要建一个原料工厂（原料包括：酱料，芝士，蔬菜，面团，腊肠等披萨原料），以免加盟店采用劣质原料，原料生产之后运送到各家加盟店，而且对于不同区域纽约，芝加哥等地的原料也不同。

OK，上代码

 

 

/**
 *  披萨原料工厂
 */
public interface PizzaIngredientFactory {
 
	/**
	 * 生产面团
	 */
	public Dough createDough();
	
	/**
     * 生产酱料
     */
	public Sauce createSauce();
	
	/**
     * 生产奶酪
     */
	public Cheese createCheese();
	
	/**
     * 生产蔬菜
     */
	public Veggies[] createVeggies();
	
	/**
     * 生产意大利式辣香肠
     */
	public Pepperoni createPepperoni();
	
	/**
     * 生产蛤蚌
     */
	public Clams createClam();
 
}

 

 

 

/**
 *  纽约披萨原料工厂，对于原料家族的每一种原料都提供纽约的版本
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
 
	public Dough createDough() {
		return new ThinCrustDough();
	}
 
	public Sauce createSauce() {
		return new MarinaraSauce();
	}
 
	public Cheese createCheese() {
		return new ReggianoCheese();
	}
 
	public Veggies[] createVeggies() {
		Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
		return veggies;
	}
 
	public Pepperoni createPepperoni() {
		return new SlicedPepperoni();
	}

	public Clams createClam() {
		return new FreshClams();
	}
}

 

 

 

public abstract class Pizza {
	String name;

	//每个披萨要用到的原料
	Dough dough;
	Sauce sauce;
	Veggies veggies[];
	Cheese cheese;
	Pepperoni pepperoni;
	Clams clam;

	/**
	 * 声明为抽象，收集披萨所需原料，而这些原料来自于工厂
	 */
	abstract void prepare();

	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}

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

	void box() {
		System.out.println("Place pizza in official PizzaStore box");
	}

	void setName(String name) {
		this.name = name;
	}

	String getName() {
		return name;
	}

	public String toString() {
		//打印披萨代码
	}
}

 

 

 

/**
 *  奶酪披萨
 */
public class CheesePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
 
	/**
	 * @param 传入原料工厂，生产出不同区域的原料
	 */
	public CheesePizza(PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}
 
	/**
	 * 原料由此而来
	 */
	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}
}

 

 

 

/**
 *  纽约披萨点
 */
public class NYPizzaStore extends PizzaStore {
 
	protected Pizza createPizza(String item) {
		Pizza pizza = null;
		PizzaIngredientFactory ingredientFactory = 
			new NYPizzaIngredientFactory();
 
		if (item.equals("cheese")) {
  
			pizza = new CheesePizza(ingredientFactory);
			pizza.setName("New York Style Cheese Pizza");
  
		} else if (item.equals("veggie")) {
 
			pizza = new VeggiePizza(ingredientFactory);
			pizza.setName("New York Style Veggie Pizza");
 
		} else if (item.equals("clam")) {
 
			pizza = new ClamPizza(ingredientFactory);
			pizza.setName("New York Style Clam Pizza");
 
		} else if (item.equals("pepperoni")) {

			pizza = new PepperoniPizza(ingredientFactory);
			pizza.setName("New York Style Pepperoni Pizza");
 
		} 
		return pizza;
	}
}

 

 

 

OK,代码就贴这些主要的，由于比较多，所以这次代码打包放在附件当中，需要的可以下载。

抽象工厂定义：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。 抽象工厂定义了一个接口，这个接口包含一组方法用来生产产品，而它的具体子类则实现图同的产品。

其实抽象工厂里面就是一个个抽象方法，每个方法用来生产一个产品，每一个可以看成是一个个工厂方法模式（定义了一个抽象方法，让其子类来实现生产出一个产品），可以看出抽象工厂需要一个大接口，很多抽象方法，用来创建整个产品家族，而工厂方法只需要一个抽象方法就可以了。这个是利用了依赖倒置原则：要依赖抽象，不要依赖于实现

这下总共讲了3个工厂了，下面总结下工厂：

1.所有的工厂都是用来封装对象的创建，达到解耦的作用。

2.工厂方法使用继承，把对象的创建延迟到子类实现，子类实现工厂方法来创建对象

3.抽象工厂使用对象组合，工厂的大接口所暴露的一个个方法来实现对象家族

 

OK，结束，本来准备写下单例模式的，不过比较晚了，每次都在公司加班写的，那就下次再写单例了