工厂方法模式定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法把实例化推迟到子类。
把创建的对象认识为产品,“由子类决定要实例化的类是哪一个。工厂方法把实例化推迟到子类”意味着使用产品的客户代码,依赖的是产品的抽象类,而不是具体化的产品。
Java提供了new关键字,当我们在程序中需要使用一个对象时,就会想到它。
Pizza orderPizza() {
Pizza pizza = new Pizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
Pizza orderPizza(String type) {
Pizza pizza;
// 变化的部分
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("greek")) {
pizza = new GreekPizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
New没有什么不对的,关键在于orderPizza依赖于具体实现类。考虑到程序的扩展性,未来我们要创建哪些类型的Pizza对象是要经常改变的,对应于程序中if语句部分是要经常改变的。
这违反了OCP原则,没有对修改关闭。解决方法:应用设计原则:封装变化,把程序中变化的部分和不变的部分隔离开。要把程序中创建产品的部分封装起来,封装对象的创建。
定义简单工厂:
public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
} else if (type.equals("clam")) {
pizza = ClamPizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
}
return pizza;
}
}
该工厂提供了创建对象的接口createPizza(String type)。下面我们看一下,该简单工厂在PizzaStore中的应用:
public class PizzaStore {
SimpPizzaFactory factory;
public PizzaStore(SimplePizzaFactory factory ) {
this.factory = factory;
}
public Pizza orderPizza(String type) {
Pizza pizza;
pizza = factory.createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
//这里是其他方法
}
PizzaStore中,使用简单工厂来创建Pizza对象。简单工厂好处说明:
把创建产品的代码封装到一个类中,当以后产品实现或者产品的种类改变时,只需要修改这个类即可,客户端PizzaStore代码不变。该简单工厂可以被许多客户使用。
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza;
pizza = createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
// 在PizzaStore中工厂方法createPizza是抽象的
abstract Pizza createPizza(String type);
}
public class NYPizzaStore extends PizzaStore {
Pizza createPizza(String item) {
if (item.equals("cheese")) {
return new NYStyleCheesePizza();
} else if (item.equals("veggie")) {
return new NYStyleVeggiePizza();
} else if (item.equals("clam")) {
return new NYStyleClamPizza();
} else if (item.equals("pepperoni")) {
return new NYStylePepperoniPizza();
} else
return null;
}
}
public class ChicagoPizzaStore extends PizzaStore {
Pizza createPizza(String item) {
if (item.equals("cheese")) {
return new ChicagoStyleCheesePizza();
} else if (item.equals("veggie")) {
return new ChicagoStyleVeggiePizza();
} else if (item.equals("clam")) {
return new ChicagoStyleClamPizza();
} else if (item.equals("pepperoni")) {
return new ChicagoStylePepperoniPizza();
} else
return null;
}
}
PizzaStore nyPizzaStore = new NYPizzaStore();
nyPizzaStore.orderPizza("cheese");
对工厂方法的认识:
超类PizzaStore 中提供了抽象工厂方法abstract Pizza createPizza(String type),该抽象工厂方法返回一个产品Pizza,该产品是抽象的。这样的话,工厂方法将客户(也就是PizzaStore中的代码,orderPizza())和实际创建具体产品的代码分离开来。
将一个orderPizza()方法和一个工厂方法联合起来,就可以成为一个框架。工厂方法模式中体现了平行的类层次:产品类和创建者类。抽象类:Pizza和PizzaStore,具体子类:NYStyle*Pizza、ChicagePizzaStore(*代表Cheese等种类)和NyPizzaStore、ChicagoPizzaStore。抽象创建者对应抽象产品,具体创建者对应具体产品。这就是类的层次结构。
简单工厂模式和工厂方法模式的比较:
1. 客户通过组合简单工厂,由工厂来创建产品。而工厂方法模式中,存在着继承关系,抽象类提供抽象工厂方法接口,而由具体子类去创建具体的产品。
2. 简单工厂模式实现了客户端的OCP原则,但是如果产品发生变化,简单工厂本身代码仍然需要修改,因此简单工厂没有完全实现OCP原则。工厂方法模式中,当有新的产品出现时,只需要扩展出新的创建者对应该新的具体产品即可,完全符合OCP原则。
4. 工厂方法模式体现了类层次结构。包括创建者类和产品类的层次对应关系。创建者类通过工厂方法来创建具体产品,并且创建者类可以应用框架,包含使用产品的客户代码(这个很强,否则只用来创建产品将是一种退化,我认为)。而简单工厂类只是创建产品,本身并不使用。
3. 两者都封装了对象的创建,使客户与具体创建产品的代码解耦。
最后,DIP原则(依赖倒置原则):要依赖抽象,不要依赖具体类。不能让高层组件以来低层组件,而且,不管高层或底层组件,“两者”都应该依赖于抽象。工厂方法模式是遵循DIP原则最有威力的技巧之一。