浅尝设计模式——如何使用工厂模式
本文为阅读《Head First 设计模式》一书的摘要总结
工厂模式
简单工厂
定义
简单工厂并不是一个设计模式，反而比较像一种编程习惯。该习惯将代码中，实例化对象的部分封装起来，独立于客户。使得客户代码满足 关闭-开放原则。
示例
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();
}
上面的代码中，实例化Pizza的部分复杂且很可能会改变，而实例化之后对Pizza方法的调用相对固定。所以我们可以将实例化Pizza的部分封装起来，形成一个简单工厂：
public class SimplePizzaFactory(){
public Pizaa createPizza(String type){
if (type.equals("cheese")){
pizza = new CheesePizza();
}else if (type.equals("greek")){
pizza = new GreekPizza();
}else if (type.equals("pepperoni")){
pizza = new PepperoniPizza();
}
}
}
public class PizzaStroe{
private SimplePizzaFactory simplePizzaFactory;
public PizzaStroe(SimplePizzaFactory simplePizzaFactory){
this.simplePizzaFactory = simplePizzaFactory;
}
Pizza orderPizza(String type){
Pizza pizza = simplePizzaFactory.createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza();
}
}
将对象实例化的过程封装起来，SimplePizzaFactory就可以有多个客户，不仅仅是现在的PizzaStroe，同时，以后实现改变时，只需要修改SimplePizzaFactory类即可。
有时候我们也可以利用静态方法创建一个简单工厂，这样我们就不需要实例化工厂类。但是这样而有一个弊端，我们不能通过继承来覆盖来改变创建方法的行为（静态方法不能被覆盖）。
工厂方法模式
定义
工厂方法模式定义了一个创建对象的接口，但由子类来决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
示例
Product超类：
public class Pizza {
String name;
void prepare(){
System.out.println("Preparing "+ name);
System.out.println("Tossing dough...");
System.out.println("Adding sauce...");
System.out.println("Adding toppings:");
}
void back(){
System.out.println("Bake for 25 minites at 350");
}
void cut(){
System.out.println("Cutting the pizza into diagonal slices");
}
void box(){
System.out.println("Place pizza in official PizzaStore box");
}
public String getName(){
return name;
}
}
具体Product：
public class NYStyleClamPizza extends Pizza{
public NYStyleClamPizza() {
this.name = "NYStyleClamPizza";
}
//覆盖父类的方法，使用自己的切片方式
public void cut(){
System.out.println("Cutting the pizza into square slices");
}
}
public class NYStyleVeggiePizza extends Pizza{
public NYStyleVeggiePizza() {
this.name = "NYStyleVeggiePizza";
}
}
工厂超类：
public abstract class PizzaStory {
public Pizza orderPizza(String type){
//创建这通常会包含依赖于抽象产品的代码
Pizza pizza = createPizza(type);
pizza.prepare();
pizza.back();
pizza.cut();
pizza.box();
return pizza;
}
protected abstract Pizza createPizza(String type);
}
为了保证制作Pizza的流程一致，所以在超类中实现orderPizza方法。还定义了一个抽象的 工厂方法 createPizza，该方法由子类来负责实现，使得不同的子类可以实例化不同类型的Pizza。
具体的工厂类：
public class NYPizzaStory extends PizzaStory{
@Override
protected Pizza createPizza(String type) {
if (type.equals("NYStyleVeggiePizza")){
return new NYStyleVeggiePizza();
}else if (type.equals("NYStyleClamPizza")){
return new NYStyleClamPizza();
}
return null;
}
}
抽象工厂模式
定义
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
抽象工厂为产品家族提供工厂，产品家族就是形成产品的一且组件。
示例
现在，我们要在上面的例子上做一些改变，我们希望可以通过工厂来提供组成Pizza的原料。
抽象工厂：
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();
}
}
抽象工厂的方法经常以工厂方法的方式实现。
Pizza超类
public abstract class Pizza {
//每种pizza都由一组原料构成，这些原料在prepare方法中被用到
String name;
Dough dough;
Sauce sauce;
Veggies veggies[];
Cheese cheese;
Pepperoni pepperoni;
Clams clam;
//这里把prepare方法定义为抽象方法，这是因为不同的Pizza类型可能由不同的成分组成，这需要有子类来实现
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;
}
}
具体的Pizza类型：
public class CheesePizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
//我们需要工厂来为CheesePizza提供原料,所以每个Pizza类都通过构造器获得一个工厂
public CheesePizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
//prepare方法一步步的制作出CheesePizza，每一步所需要的原料都由原料工厂提供。而工厂具体提供的是哪种原料取决于我们提供的工厂类型。
void prepare() {
System.out.println(“Preparing “ + name);
dough = ingredientFactory.createDough();
sauce = ingredientFactory.createSauce();
cheese = ingredientFactory.createCheese();
}
}
PizzaStore:
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;
}
}