工厂方法模式

head first 设计模式上给出的工厂方法模式定义:它定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。工厂方法让子类决定要实例化的类是哪一个,所谓的“决定”,并不是指模式允许子类本身在运行时做决定,而是指在编写创建者类时,不需要知道实际创建的产品是哪一个,选择了使用那个子类,自然就决定了实际创建的产品是什么。

这里有个很好的例子,讲的是pizza店的故事,就是说每个地方要创建不同的pizza店,而且每个地方pizza店的pizza的风味也不一样,也就是口味不一样,但在pizza店做pizza的整个流程基本是一样的。下面应用工厂方法模式来描述这种需求。

首先创建pizza类:这是基类,制作pizza的基本流程是一样的,只是在加工的时候调料不一样而已,所以把这部作为抽象方法。
  1. public abstract class Pizza {
  2.     
  3.     /*
  4.      * every pizza has its own make method.
  5.      * so you need to provide implementation by yourself;
  6.      */
  7.     public abstract void prepare();
  8.     
  9.     /*
  10.      * for pizzas, bake(),cut(),box() are the same.
  11.      * so give the default implementation.
  12.      */
  13.     public void bake(){
  14.         System.out.println("bake");
  15.     }
  16.     public void cut(){
  17.         System.out.println("cut");
  18.     }
  19.     public void box(){
  20.         System.out.println("box");
  21.     }
  22.     
  23. }
下面是PizzaStore这个工厂类。
  1. public abstract class PizzaStore {
  2.     /*
  3.      * sub class must implement this method.
  4.      * because each store has its own make method.
  5.      * so declare it to be abstract method.
  6.      * This method is much like a factory to create object.
  7.      */
  8.     protected abstract Pizza createPizza(String type);
  9.     public Pizza orderPizza(String type){
  10.         Pizza pizza = createPizza(type);
  11.         
  12.         pizza.prepare();
  13.         pizza.bake();
  14.         pizza.cut();
  15.         pizza.box();
  16.         
  17.         return pizza;
  18.     }
  19. }
可以看到其中的createPizza方法为抽象方法,来创建pizza实例。

下面是NYPizzaStore,PizzaStore的子类,实现createPizza方法。
  1. public class NYPizzaStore extends PizzaStore {
  2.     @Override
  3.     public Pizza createPizza(String type) {
  4.         if (type.equals("Chesse")){
  5.             return new NYStyleChessePizza();
  6.         }else if (type.equals("Veggie")){
  7.             return new NYStyleVeggiePizza();
  8.         }
  9.         return null;
  10.     }
  11. }
这个子类决定它要实例化的产品。

下面给出NYStyleChessePizza,和NyStyleVeggiePizza的定义。
  1. public class NYStyleChessePizza extends Pizza {
  2.     @Override
  3.     public void prepare() {
  4.         System.out.println("this is NY Style chesse pizza.");
  5.     }
  6. }
  7. public class NYStyleVeggiePizza extends Pizza {
  8.     @Override
  9.     public void prepare() {
  10.         System.out.println("this is NY style Veggie pizza.");
  11.     }
  12. }
这样就完成了一个例子,在上层是pizzaStore来创建pizza,而在实例化层面是NYPizzaStore在创建NYStyle Pizza。刚好是平行的关系。

下面是测试的一段代码。
  1. public class TestAbstractFactoryMethod {
  2.     public static void main(String[] args) {
  3.         PizzaStore pizzaStore = new NYPizzaStore();
  4.         pizzaStore.orderPizza("Chesse");
  5.         pizzaStore.orderPizza("Veggie");
  6.     }
  7.     
  8. }
运行的结果是:
this is NY Style chesse pizza.
bake
cut
box
this is NY style Veggie pizza.
bake
cut
box

我相信大家看了这个例子后,将会很对工厂方法模式有个更清晰的认识。如果想更好的理解工厂方法模式,还是要更多的实践。

你可能感兴趣的:(设计模式,String,测试,产品)