如今比萨店成功的关键在于新鲜、高质量的原料,而且通过导入新的框架,加盟点将遵循你的流程,但是有一些加盟店,使用低价原来来增加利润。你必须采用一些手段,以免长此以往毁了品牌
确保原料一致,你打算建造一家生产原料的工厂,并将原料运送到各家加盟店。那么问题来了,加盟店坐落于不同的区域,纽约的红酱料和芝加哥的红酱料是不一样的。所以对于纽约和芝加哥你需要准备两组不同的原料。
芝加哥比萨菜单:
芝士披萨:番茄酱料,意大利白干酪,Parmesan干酪,比萨草。
素食披萨:番茄酱料,意大利白干酪,Parmesan干酪,茄子,菠菜,黑橄榄。
…..
纽约比萨菜单:
芝士披萨:大蒜番茄酱料,Reggiano干酪,大蒜。
素食披萨:大蒜番茄酱料,Reggiano干酪,蘑菇,洋葱,红辣椒。
…..
这表明我们有相同的产品家族:面团,意式腊肠,酱料,芝士,蔬菜,肉。但是制作方式根据区域不同而有差异。
纽约使用一组原料,而芝加哥使用另一组原料。可能不久之后加州就有了加盟店,到时候又需要运送另外一组区域的原料,接着呢?西雅图吗?
想要行得通,必须先清楚如何处理原料家族。
一、首先建造原料工厂
/**
* 建造一个原料工厂,它是一个接口
* 这个工厂将负责创建原料家族中的每一种原料。
* @author Administrator
*
*/
public interface PizzaIngredientFactory {
public Dough createDough();
public Sauce createSauce();
public Cheese createCheese();
public Veggies[] createVeggies();
public Pepperoni createPepperoni();
public Clams createClam();
/*
* 如果每个工厂实例内都有某一种通用的“机制”需要实现,
* 就可以把这个列字改写成抽象类。
*/
}
二、创建纽约原料工厂
/**
* 创建纽约原料工厂
* @author Administrator
* 同理,参照本来可以实现ChicagoPizzaIngredientFactory
*
*/
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
@Override
public Dough createDough() {
return new ThinCrustDough();
}
@Override
public Sauce createSauce() {
return new MarinaraSauce();
}
//以下其他的实现原料具体类,类似做法。
@Override
public Cheese createCheese() {
// TODO Auto-generated method stub
return null;
}
@Override
public Veggies[] createVeggies() {
// TODO Auto-generated method stub
return null;
}
@Override
public Pepperoni createPepperoni() {
// TODO Auto-generated method stub
return null;
}
@Override
public Clams createClam() {
// TODO Auto-generated method stub
return null;
}
}
三、重做披萨
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.....");
}
void box() {
System.out.println("boxing...");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
//这里是打印披萨的代码
return null;
}
}
四、实例化具体的披萨
/**
* 具体的披萨--芝士披萨
* @author Administrator
* 同理,可实现其他具体披萨
*
*/
public class CheesePizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public CheesePizza (PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
@Override
void prepare() {
System.out.println("Preparing " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
**
* 蛤俐披萨
* @author Administrator
*
*/
public class ClamPizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public ClamPizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
/**
* Pizza的代码利用相关的工厂生产原料,所生产的原料依赖所使用的工厂,
* Pizza类根本不关心这些原料,它只知道如何制作披萨
*/
@Override
void prepare() {
System.out.println("Preparing " + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
五、再回到披萨店
**
* 披萨店超类
* @author Administrator
*
*/
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza = null;
pizza = createPize(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
abstract Pizza createPize(String type);
}
/**
* 具体的披萨店。
* 当然其他的披萨店也可以参照这个来实现
* @author Administrator
*
*/
public class NYPizzaStore extends PizzaStore {
@Override
Pizza createPize(String type) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
if ("Cheese".equals(type)) {
pizza = new CheesePizza(ingredientFactory);
} else if ("Clam".equals(type)) {
pizza = new ClamPizza(ingredientFactory);
}
// ....此处省略
return pizza;
}
}
六、原料和一些具体的原料。其他的就不贴代码了
public interface Dough {
}
public class ThinCrustDough implements Dough {
}
总结:工厂模式----定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
设计原则:依赖抽象,不要依赖具体类。