项目实例
假设你有一家 pizza 店,你有很多种 pizza,要在系统中显示你所有 pizza 种类。实现这个功能并不难,使用普通方式实现:
public class PizzaStore {
Pizza orderPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("clam")) {
pizza = new ClamPizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}}
这种把选择披萨和制作过程全放在一起,如果新推出一款披萨就要修改 OrderPizza 方法,不符合开闭原则。
我们可已经这段变化的代码移到一个专门的类中,这个类只管创建 Pizza,我们将这个类的对象称之为“工厂”;
简单工厂(factory)
根据“将变化抽离并封装“的原则,我们可以将创建 pizza 实例这一块给抽离出来,因为这块后边可能会新增一些别的 pizza 类型,由一个对象来专职创建 pizza 对象。如果有一个 SimplePizzaFactory,那么 orderPizza() 就变成此对象的客户;
当客户下单,pizzaStore 调用 orderPizza() 的时候,就叫比萨工厂做一个,orderPizza() 只关心从工厂得到一个比萨;
public class SimplePizzaFactory {
public PizzaCreatePizza(string pizzaType){
Pizza pizza = null;
if(pizzaType.Equals("cheese"))
pizza = newCheesePizza();
else if (pizzaType.Equals("pepperoni"))
pizza = newPepperoniPizza();
else if(pizzaType.Equals("clam"))
pizza = newCalmPizza();
else if(pizzaType.Equals("veggie"))
pizza = newVeggiePizza();
return pizza;
}
}
接下来看下 Pizza 类:
public class Pizza {
Pizza OrderPizza(stringpizzaType){
Pizza pizza;
SimplePizzaFactory simplePizzaFactory = new SimplePizzaFactory();//生成pizza
pizza =simplePizzaFactory.CreatePizza(pizzaType);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
这样的话,就可以遵循了把变化的部分抽象成一个类。下次需要变化,只需要对变化的类的部分做修改即可。
下面给出其UML图。
简单工厂的目的,主要负责实现生产对象的细节,根据订单来生产。每一个商店有对应着自己的工厂。在此,可以将 OrderPizza 是工厂的一个客户,当然还可以是其他类似的方法,比如 PizzaShopMenu 也可以是工厂的客户。客户就是为了获取工厂生成的对象。前者是为了卖给 people,后者是为了使用 Pizza 类获取其描述和价格等。这样遵循了找出变化的部分,将其封装到一个类中的原则,从而到达了复用的目的。
简单工厂之所以简单是因为它只根据需要,来生产出来指定的 Pizza。
特点:所有的产品都由一个工厂来生产。
上面的简单工厂并不是一个真正的模式,只是一种编程习惯,这个不能算工厂模式,不过也算是基本满足需求。
接下来我们来看看工厂方法的实现。
工厂方法
背景更新:
假如现在你要开分店,各种加盟商进来后,他们都要开发符合本地口味的 pizza,那就需要各个地方都有一个工厂,也就是每个地方继承 SimpleFactory类,但是每个工厂并不是完全使用你原来的烘培方法。或许,我们可以像 1 中那样利用简单的工厂,对应不同地区的加盟店创建不同的工厂。
这样做导致的另一个问题就是,不同的加盟店披萨的制作流程、方法可能不同,如何才能把加盟店和创建披萨捆绑在一起的同时又保持一定的弹性?
我们可以把 CreatePizza()方法放回到 PizzaStore 中,但是要把它设置为抽象方法,然后为每一个区域加盟店创建一个 PizzaStore 的子类。
如下所示:
对应的代码如下:
public abstract class PizzaStore {
public OrderPizza(string pizzaType) {
Pizza pizza =CreatePizza(pizzaType);
pizza.Prepare();
pizza.Bake();
pizza.Cut();
pizza.Box();
return pizza;
}
public abstract Pizza CreatePizza(string pizzaType); //把工厂对象移到该方法中,该方法为抽象方法
}
对应于两家分店的代码:
public class NYPizzaStore extends PizzaStore {
@Override
protected Pizza createPizza(String type) {
if (type.equals("cheese")) {
return new NYCheesePizza();
}
return null;
}
}
public class ChicagoPizzaStore extends PizzaStore {
@Override
protected Pizza createPizza(String type) {
if (type.equals("cheese")) {
return new ChicagoCheesePizza();
}
return null;
}
}
我们需要建立一个 Pizza 实体类:
public abstract class Pizza {
String name; //名称
String dough; //面团类型
String sauce; //酱料
ArrayList<String> toppings = new ArrayList<String>(); //作料
void prepare() {
System.out.println("准备 " + name);
System.out.println("揉面团...");
System.out.println("添加酱料...");
System.out.println("添加作料: ");
for (int i = 0; i < toppings.size(); i++) {
System.out.println(" " + toppings.get(i));
}
}
void bake() {
System.out.println("烘烤25分钟");
}
void cut() {
System.out.println("把Pizza对角切片");
}
void box() {
System.out.println("把Pizza装盒子");
}
public String getName() {
return name;
}
}
然后需要一些具体的子类,下边定义两个子类:纽约风味的芝士披萨(NYStyleCheesePizza)、芝加哥风味的芝士披萨 (ChicageStyleCheesePizza)
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 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 Mozzarella Cheese");
}
//可以覆盖cut()方法
void cut() {
System.out.println("Cutting the pizza into square slices");
}
}
总结
所有工厂模式都用来封装对象创建,工厂方法模式通过让子类决定该创建的对象是什么,来达到将对象创建的过程封装的目的。
工厂方法模式定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个,工厂方法让类把实例化推迟到子类。
- 创建者(Creator)类
- 产品类
简单工厂和工厂方法之间的差异?
简单工厂是在一个地方把所有的事都处理完了,然而工厂方法却是创建一个框架,让子类决定要如何实现。简单工厂的做法,可以将对象的创建封装起来,但是简单工厂不具备工厂方法的弹性,因为简单工厂不能变更正在创建的产品。
抽象工厂
创建工厂接口
回到上文的 Pizza 店,现在有新的需求,想要确保每家加盟店使用高质量的材料,打算创建一家生产原料的加工厂,并将原料送到各个加盟店。这个工厂负责创建原料家族中的每一种原料,工厂需要生产面团、酱料、芝士等。先为工厂定义一个接口,该接口负责所有原料:
public interface PizzaIngredientFactory {
Dough CreateDough();
Sauce CreateSauce();
Cheese CreateCheese();
Veggies[] CreateVeggies();
Pepperoni CreatePepperoni();
Clams CreateClam();
}
创建一个原料厂
//具体原料工厂必须实现这个接口
public class NYPizzaIngredientFactory extends 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 Veggies[]{ new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
return veggies;
}
public Pepperoni CreatePepperoni() {
return new SlicedPepperoni();
}
public Clams CreateClam() {
return new FreshClams();
}
}
重新抽象 Pizza 类
public abstract class Pizza {
public string name;
public Dough dough;
public Sauce sauce;
public Veggies[] veggies;
public Cheese cheese;
public Pepperoni pepperoni;
public Clams clam;
public ArrayList toppings = newArrayList();
public abstract void Prepare();//把Prepare()方法声明成抽象,在这个方法中,我们需要收集Pizza所需的原材料,而这些原材料来自原料工厂。
public void Bake() {
System.Console.WriteLine("Bakefor 25 minutes at 350");
}
public void Cut() {
System.Console.WriteLine("Cuttingthe pizza into diagonal slices");
}
public void Box() {
System.Console.WriteLine("Placepizza in official PizzaStore box");
}
public string GetName() {
return name;
}
}
重新实现 Pizza
public class NYStyleCheesePizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public NYStyleCheesePizza(PizzaIngredientFactoryingredientFactory){ //制作Pizza需要工厂提供原材料,所以每个pizza类都需要从构造器中得到一个工厂,并将工厂存储在变量中
this.ingredientFactory =ingredientFactory;
name = "NY StyleSauc and Cheese Pizza";
toppings.Add("GratedReggiano Cheese");
}
public override void Prepare()
{
System.Console.WriteLine("Preparing" + name);
dough = ingredientFactory.CreateDough();
sauce = ingredientFactory.CreateSauce();
cheese = ingredientFactory.CreateCheese();
}
}
重新生产pizza
public class MYPizzaStore extends PizzaStore {
public override Pizza CreatePizza(string type) {
Pizza pizza=null;
PizzaIngredientFactory ingredientFactory= new NYPizzaIngredientFactory();
switch(type) {
case "cheese":
pizza = new NYStyleCheesePizza(ingredientFactory);
break;
case "veggie":
pizza=new NYStyleVeggiePizza(ingredientFactory);
break;
case "clam":
pizza=new NYStyleClamPizza(ingredientFactory);
break;
case "pepperoni":
pizza=new NYStylePepperoniPizza(ingredientFactory);
break;
}
return pizza;
}
}
通过这一系列的操作,我们引入了新类型的工厂,也就是所谓的“抽象工厂”,来创建 pizza 原来家族。通过抽象工厂所提供的接口创建产品家族,利用这个接口书写代码,我们的代码将从实际工厂解耦,以便在不同上下文中实现各式各样的工厂,制造出各种不同的产品。
定义抽象工厂模式
抽象工厂模式提供一个接口,用于创建相关或依赖对象家族,而且不需要致命具体类。
抽象工厂模式允许客户使用抽象的接口来创建一组相关的产品,而不需要知道实际产出的具体产品是什么,客户就从具体的产品中被解耦。
抽象工厂与工厂方法的对比
抽象工厂和工厂方法都是负责创建对象。
抽象工厂是通过对象的组合
定义了一个创建对象的接口,但由于子类决定要实例化的类是哪一个,工厂方法让类把实例化推迟到子类。
所以利用工厂方法创建对象时,需要扩展一个类,并覆盖它的工厂方法。
整个工厂方法模式,只不过就是通过子类来创建对象,这种做法,客户只需要知道他们所使用的抽象类型就可以了,而由子类负责决定具体类型。将客户从具体类型中解耦。
工厂方法是继承。
抽象工厂方法是将一群相关的产品集合起来,用于创建相关或依赖对象的家族,而不需要明确指定具体类。